passive_record 0.4.14 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cacd9ce096b75a0cb189db566c1b506263462bcd
-  data.tar.gz: 6d05d9c4520b4f8a7365ff587ee72e49fcb93f37
+  metadata.gz: 2e72e0564a1b8661c945d597f7419a24c9b00eb8
+  data.tar.gz: 1ff3f8c8430a145d19d6ea2c7c17e69a067a15b1
 SHA512:
-  metadata.gz: 56634dcfa1edfa95df038ace1d9ea482b95a3d4766961dd802955cbd35f37311a3b97d2d97f93fc255fdafd248ce7dbae7fa867de964f4a6f2dfa950fd24331f
-  data.tar.gz: 7aa8cec6e8442a4e9c7eb7a2cf1a72acd686028577b9604ef9ee373977a7deda2d8c3673fb6a9303eaaea713f0eae3289d18f06761afabd34d6cdbaf5bea6ba2
+  metadata.gz: 7f0fabaab580b4b110f49b16367f945180e8da5c5228d151caae2eb1bdbe9c85e8f85b2aab3d44fcb6136ac062d4a41d0e12f5699059b2b421484b14c1a30acd
+  data.tar.gz: 4d5cc36aa5a22c8a6573f7e653c5cfdfff04668ed3f150277f33546de1c3936bdab49e02886bdf979e63ca34e825c67c7363fffc834acb42dbfddb9086c12ffe

data/README.md

@@ -44,6 +44,7 @@ PassiveRecord may be right for you!
     end
 
     class Dog < Model
+      attr_accessor :breed
       belongs_to :child
     end
 
@@ -64,26 +65,25 @@ PassiveRecord may be right for you!
     child = parent.create_child
     => Child (id: 1, dog_id: nil, parent_id: 1)
 
-    dog = child.create_dog
-    => Dog (id: 1, child_id: 1)
+    dog = child.create_dog(breed: "Pug")
+    => Dog (id: 1, child_id: 1, breed: "Pug")
 
     # Inverse relationships
     dog.child
-    => Child (id: 1, dog_id: 1, parent_id: 1)
 
     Dog.find_by child: child
-    => Dog (id: 1, child_id: 1)
+    => Dog (id: 1, child_id: 1, breed: "Pug")
 
     # Has many through
     parent.dogs
     => [ ...has_many :through relation... ]
 
     parent.dogs.all
-    => [Dog (id: 1, child_id: 1)]
+    => [Dog (id: 1, child_id: 1, breed: "Pug")]
 
     # Nested queries
     Dog.find_all_by(child: { parent: parent })
-    => [Dog (id: 1, child_id: 1)]
+    => [Dog (id: 1, child_id: 1, breed: "Pug")]
 ````
 
 ## PassiveRecord API

data/lib/passive_record/associations.rb

@@ -32,7 +32,7 @@ module PassiveRecord
       end
 
       define_method(parent_name_sym) do
-        relation = relata.detect { |rel| rel.association == association }
+        relation = detect_relation(association)
         association.parent_class.find(relation.parent_model_id)
       end
 
@@ -41,7 +41,7 @@ module PassiveRecord
       end
 
       define_method(:"#{parent_name_sym}_id=") do |new_parent_id|
-        relation = relata.detect { |rel| rel.association == association }
+        relation = detect_relation(association)
         relation.parent_model_id = new_parent_id
       end
     end
@@ -57,12 +57,12 @@ module PassiveRecord
       end
 
       define_method(child_name_sym) do
-        relation = relata.detect { |rel| rel.association == association }
+        relation = detect_relation(association)
         relation.lookup
       end
 
       define_method(:"create_#{child_name_sym}") do |attrs={}|
-        relation = relata.detect { |rel| rel.association == association }
+        relation = detect_relation(association)
         relation.create(attrs)
       end
 
@@ -71,7 +71,7 @@ module PassiveRecord
       end
 
       define_method(:"#{child_name_sym}_id=") do |new_child_id|
-        relation = relata.detect { |rel| rel.association == association }
+        relation = detect_relation(association) #relata.detect { |rel| rel.association == association }
         rel = relation.lookup
         rel && rel.send(:"#{relation.parent_model_id_field}=", nil)
 
@@ -102,7 +102,7 @@ module PassiveRecord
         end
 
         define_method(:"#{collection_name_sym.to_s.singularize}_ids=") do |new_collection_ids|
-          relation = relata.detect { |rel| rel.association == association }
+          relation = detect_relation(association) # relata.detect { |rel| rel.association == association }
 
           intermediary = relation.intermediary_relation
 
@@ -113,16 +113,16 @@ module PassiveRecord
 
           # add in new ones...
           singular_target = collection_name_sym.to_s.singularize
-          if !(relation.nested_association.is_a?(BelongsToAssociation))# && 
+          if !(relation.nested_association.is_a?(BelongsToAssociation))
             intermediary.create(
               singular_target + "_ids" => new_collection_ids,
-              relation.parent_model_id_field => relation.id 
+              relation.parent_model_id_field => relation.id
             )
           else
             new_collection_ids.each do |child_id|
               intermediary.create(
-                singular_target + "_id" => child_id, 
-                relation.parent_model_id_field => relation.id 
+                singular_target + "_id" => child_id,
+                relation.parent_model_id_field => relation.id
               )
             end
           end
@@ -132,7 +132,7 @@ module PassiveRecord
         associate!(association)
 
         define_method(:"#{collection_name_sym}=") do |new_collection|
-          relation = relata.detect { |rel| rel.association == association }
+          relation = detect_relation(association)
 
           # detach existing children...
           relation.all.each do |child|
@@ -146,21 +146,26 @@ module PassiveRecord
         end
 
         define_method(:"#{collection_name_sym.to_s.singularize}_ids=") do |new_collection_ids|
-          relation = relata.detect { |rel| rel.association == association }
+          relation = detect_relation(association) #@ relata.detect { |rel| rel.association == association }
           send(:"#{collection_name_sym}=", relation.child_class.find(new_collection_ids))
         end
       end
 
       define_method(collection_name_sym) do
-        relata.detect { |rel| rel.association == association }
+        detect_relation(association)
+        # relata.detect { |rel| rel.association == association }
       end
 
       define_method(:"#{collection_name_sym.to_s.singularize}_ids") do
-        send(collection_name_sym).map(&:id)
+        begin
+          send(collection_name_sym).map(&:id)
+        rescue
+          binding.pry
+        end
       end
 
       define_method(:"create_#{collection_name_sym.to_s.singularize}") do |attrs={}|
-        relation = relata.detect { |rel| rel.association == association }
+        relation = detect_relation(association) # relata.detect { |rel| rel.association == association }
         relation.create(attrs)
       end
     end

data/lib/passive_record/associations/belongs_to.rb

@@ -6,9 +6,11 @@ module PassiveRecord
       end
 
       def parent_class
-	module_name = child_class.name.deconstantize
-	module_name = "Object" if module_name.empty?
-	(module_name.constantize).const_get(parent_class_name)
+        @parent_class ||= (
+          module_name = child_class.name.deconstantize
+          module_name = "Object" if module_name.empty?
+          (module_name.constantize).const_get(parent_class_name)
+        )
       end
 
       def child_class_name

data/lib/passive_record/associations/has_many_through.rb

@@ -4,11 +4,6 @@ module PassiveRecord
       def to_relation(parent_model)
         HasManyThroughRelation.new(self, parent_model)
       end
-
-      def nested_association
-        thru_klass = base_association.child_class_name.singularize.constantize
-        thru_klass.associations.detect { |assn| assn.child_class_name == child_class_name }
-      end
     end
 
     class HasManyThroughRelation < HasManyRelation
@@ -69,9 +64,9 @@ module PassiveRecord
         if intermediate_results && !join_results.empty?
           final_results = join_results.flat_map(&nested_association.target_name_symbol)
           if final_results.first.is_a?(Associations::Relation)
-            final_results.flat_map(&:all)
+            final_results.flat_map(&:all).compact
           else
-            Array(final_results)
+            Array(final_results.compact)
           end
         else
           []
@@ -90,61 +85,13 @@ module PassiveRecord
         end
       end
 
-      def intermediary_conditions
-        if intermediary_relation.is_a?(HasManyThroughRelation)
-          conds = intermediary_relation.intermediary_conditions
-
-          if nested_association.habtm || nested_association.is_a?(HasManyThroughAssociation)
-            { association.through_class => conds }
-          else
-            { association.through_class.to_s.singularize.to_sym => conds }
-          end
-        elsif intermediary_relation.association.is_a?(HasManyAssociation) # normal has many?
-          intermediary_key = if association.is_a?(HasManyThroughAssociation)
-                               ch = association.child_class_name.constantize
-                               inverse_assn = ch.associations.detect { |assn| 
-                                 if assn.is_a?(HasManyAssociation) || assn.is_a?(HasManyThroughAssociation)
-                                   assn.child_class_name == association.base_association.child_class_name
-                                 else # belongs to...
-                                   assn.parent_class_name == association.base_association.child_class_name
-                                 end
-                               }
-
-                               if inverse_assn.nil?
-                                 association.through_class.to_s.singularize.to_sym
-                               elsif inverse_assn.is_a?(HasManyAssociation) || inverse_assn.is_a?(HasManyThroughAssociation)
-                                 inverse_assn.children_name_sym
-                               else
-                                 inverse_assn.target_name_symbol
-                               end
-                             elsif association.habtm
-                               association.base_association.children_name_sym
-                             else
-                               association.base_association.children_name_sym.to_s.singularize.to_sym
-                             end
-
-          nested_conds = { intermediary_key => { parent_model_id_field.to_sym => parent_model.id } }
-
-          if nested_association.is_a?(HasManyThroughAssociation)
-            n = nested_association
-            hash = nested_conds
-
-            until !n.is_a?(HasManyThroughAssociation)
-              key = n.through_class.to_s.singularize.to_sym
-              hash = {key => hash}
-              n = n.nested_association
-            end
-
-            hash
-          else
-            nested_conds
-          end
-        end
-      end
-
       def where(conditions={})
-        merged_conditions = conditions.merge(intermediary_conditions)
-        child_class.where(merged_conditions)
+        Core::HasManyThroughQuery.new(
+          child_class,
+          parent_model,
+          association.target_name_symbol,
+          conditions
+        )
       end
     end
   end

data/lib/passive_record/associations/has_one.rb

@@ -40,9 +40,11 @@ module PassiveRecord
       end
 
       def child_class
-	module_name = association.parent_class.name.deconstantize
-	module_name = "Object" if module_name.empty?
-	(module_name.constantize).const_get(association.child_class_name.singularize)
+        @child_class ||= (
+          module_name = association.parent_class.name.deconstantize
+          module_name = "Object" if module_name.empty?
+          (module_name.constantize).const_get(association.child_class_name.singularize)
+        )
       end
 
       def id

data/lib/passive_record/core/query.rb

@@ -25,26 +25,30 @@ module PassiveRecord
         if @scope
           matching = @scope.method(:matching_instances)
           if negated?
-            @klass.reject(&matching)
+            raw_all.reject(&matching)
           else
-            @klass.select(&matching)
+            raw_all.select(&matching)
           end
         else
           matching = method(:matching_instances)
-          @klass.select(&matching)
+          raw_all.select(&matching)
         end
       end
       def_delegators :all, :sample
 
+      def raw_all
+        @klass.all
+      end
+
       def each
         if @scope
           matching = @scope.method(:matching_instances)
           if negated?
-            @klass.all.each do |instance|
+            raw_all.each do |instance|
               yield instance unless matching[instance]
             end
           else
-            @klass.all.each do |instance|
+            raw_all.each do |instance|
               yield instance if matching[instance]
             end
           end
@@ -182,5 +186,18 @@ module PassiveRecord
         true
       end
     end
+
+    class HasManyThroughQuery < Query
+      def initialize(klass, instance, target_name_sym, conditions={})
+        @klass = klass
+        @instance = instance
+        @target_name_sym = target_name_sym
+        @conditions = conditions
+      end
+
+      def raw_all
+        @instance.send(@target_name_sym).all
+      end
+    end
   end
 end

data/lib/passive_record/instance_methods.rb

@@ -52,6 +52,13 @@ module PassiveRecord
       []
     end
 
+    def detect_relation(assn)
+      @_associations ||= {}
+      @_associations[assn] ||= (
+        relata.detect { |rel| rel.association == assn }
+      )
+    end
+
     private
 
     def relata

data/lib/passive_record/version.rb

@@ -1,4 +1,4 @@
 module PassiveRecord
   # passive_record version
-  VERSION = "0.4.14"
+  VERSION = "0.4.15"
 end

data/spec/passive_record_spec.rb

@@ -288,64 +288,124 @@ describe "passive record models" do
         end
 
         context 'querying with scopes through relationships' do
-          let!(:network) { Network.create }
-          let!(:stream) { network.create_stream }
-          let!(:channel) { stream.create_channel }
-          let!(:feed) { channel.create_feed }
-          let!(:a_blog) { feed.create_blog }
+          let(:network) { Network.create }
+          let(:stream) { network.create_stream }
+          let(:channel) { stream.create_channel }
+          let(:feed) { channel.create_feed }
+          let(:a_blog) { feed.create_blog }
+
           let!(:not_recent_post) { a_blog.create_post(published_at: 10.days.ago) }
           let!(:recent_post) do
             a_blog.create_post(published_at: 1.day.ago)
           end
 
+          let!(:special_category)   { recent_post.create_category(special: true) }
+          let!(:unspecial_category) { recent_post.create_category(special: false) }
+
+          let!(:approved_comment)   { recent_post.create_comment(approved: true) }
+          let!(:unapproved_comment) { recent_post.create_comment(approved: false) }
+
+          ###
+          #
+          let(:another_network) { Network.create }
+          let(:another_stream) { another_network.create_stream }
+          let(:another_channel) { another_stream.create_channel }
+          let(:another_feed) { another_channel.create_feed }
+          let(:another_blog) { another_feed.create_blog }
+
+
+          let!(:post_from_unrelated_blog) { another_blog.create_post(published_at: 1.day.ago) }
+          let!(:unrelated_comment) do
+            post_from_unrelated_blog.create_comment(approved: true)
+          end
+
+          let!(:another_category) do
+            post_from_unrelated_blog.create_category(special: true)
+          end
+
           describe 'should find related models through a has many' do
-            it 'should restrict' do
+            it 'should refine' do
               expect(a_blog.posts.recent).to include(recent_post)
               expect(a_blog.posts.recent).not_to include(not_recent_post)
             end
+
+            it 'should restrict' do
+              a_blog.posts.all.each do |post|
+                expect(another_blog.posts.all.map(&:id)).not_to include(post.id)
+              end
+            end
           end
 
           describe 'should find related models on a has_many through' do
-            it 'should restrict' do
+            it 'should refine' do
               expect(feed.posts.recent).to include(recent_post)
               expect(feed.posts.recent).not_to include(not_recent_post)
             end
+
+            it 'should restrict' do
+              feed.posts.each do |post|
+                expect(another_feed.posts).not_to include(post)
+              end
+            end
           end
 
           describe 'should find related models on a nested has_many thru' do
-            it 'should restrict' do
+            it 'should refine' do
               expect(channel.posts.recent).to include(recent_post)
               expect(channel.posts.recent).not_to include(not_recent_post)
             end
+
+            it 'should restrict' do
+              channel.posts.each do |post|
+                expect(another_channel.posts).not_to include(post)
+              end
+            end
           end
 
           describe 'should find related models on a double-nested has_many thru' do
-            it 'should restrict' do
+            it 'should refine' do
               expect(stream.posts.recent).to include(recent_post)
               expect(stream.posts.recent).not_to include(not_recent_post)
             end
+
+            it 'should restrict' do
+              expect(stream.posts.all).not_to be_empty
+              stream.posts.all.each do |post|
+                expect(another_stream.posts.all).not_to include(post)
+              end
+            end
           end
 
           describe 'should find related models on a deeply nested has_many thru' do
-            it 'should restrict' do
+            it 'should refine' do
               expect(network.posts.recent).to include(recent_post)
               expect(network.posts.recent).not_to include(not_recent_post)
             end
+
+            it 'should restrict' do
+              network.posts.all.each do |post|
+                expect(another_network.posts.all.map(&:id)).not_to include(post.id)
+              end
+            end
           end
 
           describe 'should find related models on a recursive has_many thru' do
-            let!(:approved_comment) { Post.first.create_comment(approved: true) }
-            let!(:unapproved_comment) { Post.last.create_comment(approved: false) }
-
-            it 'should refine/restrict' do
+            it 'should refine' do
               expect(network.comments.approved).to include(approved_comment)
               expect(network.comments.approved).not_to include(unapproved_comment)
             end
+
+            it 'should restrict' do
+              expect(network.comments.all).not_to be_empty
+              network.comments.all.each do |comment|
+                expect(another_network.comments).not_to include(comment)
+              end
+            end
           end
 
           describe 'should find related models a recursive has_many :thru a habtm' do
-            let!(:promoted_tag) { Post.first.create_tag(promoted: true) }
-            let!(:unpromoted_tag) { Post.last.create_tag(promoted: false) }
+            let!(:promoted_tag) { recent_post.create_tag(promoted: true) }
+            let!(:unpromoted_tag) { recent_post.create_tag(promoted: false) }
 
             it 'should refine and restrict' do
               expect(network.tags.promoted).to include(promoted_tag)
@@ -354,13 +414,19 @@ describe "passive record models" do
           end
 
           describe 'should find related nested models through a manual habtm' do
-            let!(:special_category) { Post.first.create_category(special: true) }
-            let!(:unspecial_category) { Post.last.create_category(special: false) }
 
-            it 'should refine and restrict' do
+            it 'should refine' do
               expect(network.categories.special).to include(special_category)
               expect(network.categories.special).not_to include(unspecial_category)
             end
+
+            it 'should restrict' do
+              expect(another_network.categories.all).not_to be_empty
+              expect(network.categories.all).not_to be_empty
+              another_network.categories.where.all.each do |category|
+                expect(network.categories.where.all).not_to include(category)
+              end
+            end
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: passive_record
 version: !ruby/object:Gem::Version
-  version: 0.4.14
+  version: 0.4.15
 platform: ruby
 authors:
 - Joseph Weissman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-19 00:00:00.000000000 Z
+date: 2016-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport