passive_record 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1df1e784cf91a0992f637e1d716f80e480735de6
-  data.tar.gz: c42d72d513f9b2970ac550fac9ba4bf6cf17cf5f
+  metadata.gz: ca6a576aa3a31b7353bc0c5eb63341f499e8ae44
+  data.tar.gz: b341ffd2c74c73110f91c6de4f409cfe8705ffb1
 SHA512:
-  metadata.gz: 2ac681f63db9780ce9604356125fe2d3e76efc029958e258c098da5a35599db0b871aa6fabe393dce3c6310d01bcd6f85758f7a63633ea695ad612f9d7905fd7
-  data.tar.gz: b91ffa6952369232fd89ae1c88b18cedcd6274a554c52845ebc523fda6bb32aaa641dcec8eb3f6191eec141a8b16be165812f4828d9175d636b47083147fc070
+  metadata.gz: 11bb9c9f548185b19bf87c62264266d4529161f5b198f0b62e1bf85fd3dd8b1c63036a97b2d0ff818a6538a2f07e97303fe04d227012fff56ecb2cc0c64afe90
+  data.tar.gz: 99105eb8a1b8fbd8d50b166deaa98f7a671ab730736684d89a3c3e386a4fba242360f45fa1792d3be857adfa60d56c8ba9ac6838fb36620529f2877217a91a4d

data/lib/passive_record/associations.rb

@@ -82,14 +82,15 @@ module PassiveRecord
     end
 
     def has_many(collection_name_sym, opts={})
-      target_class_name = opts.delete(:class_name) { (collection_name_sym.to_s).split('_').map(&:capitalize).join }
+      target_class_name = opts.delete(:class_name) { (collection_name_sym.to_s).split('_').map(&:capitalize).join.singularize }
       habtm = opts.delete(:habtm) { false }
 
       association = nil
       if opts.key?(:through)
         through_class_collection_name = opts.delete(:through)
 
-        through_class_name = (through_class_collection_name.to_s).split('_').map(&:capitalize).join
+        through_class_name = (through_class_collection_name.to_s).split('_').map(&:capitalize).join.singularize
+        # binding.pry if through_class_collection_name == :blogs
         base_association = associations.detect { |assn| assn.child_class_name == through_class_name rescue false }
 
         association = HasManyThroughAssociation.new(
@@ -180,8 +181,8 @@ module PassiveRecord
       intended_module = module_name.constantize
 
       if (intended_module.const_get(inverse_habtm_join_class_name) rescue false)
-        has_many inverse_habtm_join_class_name.underscore.pluralize.to_sym
-        has_many collection_name_sym, :through => inverse_habtm_join_class_name.underscore.pluralize.to_sym, habtm: true
+        has_many inverse_habtm_join_class_name.underscore.to_sym
+        has_many collection_name_sym, :through => inverse_habtm_join_class_name.underscore.to_sym, habtm: true
       else
         auto_collection_sym = self.name.split('::').last.underscore.pluralize.to_sym
         eval <<-ruby
@@ -191,8 +192,8 @@ module PassiveRecord
           belongs_to :#{auto_collection_sym.to_s.singularize}   #   belongs_to :user
         end                                                     # end
         ruby
-        has_many habtm_join_class_name.underscore.pluralize.to_sym
-        has_many(collection_name_sym, :through => habtm_join_class_name.underscore.pluralize.to_sym, habtm: true)
+        has_many habtm_join_class_name.underscore.to_sym
+        has_many(collection_name_sym, :through => habtm_join_class_name.underscore.to_sym, habtm: true)
       end
     end
   end

data/lib/passive_record/associations/has_many_through.rb

@@ -79,6 +79,7 @@ module PassiveRecord
       end
 
       def intermediary_relation
+        # binding.pry
         @intermediary_relation ||= association.base_association.to_relation(parent_model)
       end
 
@@ -100,11 +101,29 @@ module PassiveRecord
             { association.through_class.to_s.singularize.to_sym => conds }
           end
         elsif intermediary_relation.association.is_a?(HasManyAssociation) # normal has many?
-          intermediary_key = if association.habtm
+          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
-                               intermediary_relation.association.children_name_sym.to_s.singularize.to_sym
+                               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)

data/lib/passive_record/version.rb

@@ -1,4 +1,4 @@
 module PassiveRecord
   # passive_record version
-  VERSION = "0.4.11"
+  VERSION = "0.4.12"
 end

data/notes.md

@@ -40,3 +40,37 @@ Post.where(blog: { feed: { channel: { stream: 890 }}})
 Post.where(published_at: 1.day.ago...Time.now, blog: { feed: { channel: { stream: { network_id: 1234 }}}})
 
 
+---------
+
+
+
+Okay, so in this case we are trying to do `feed.posts.recent` ....
+
+=> #<struct PassiveRecord::Associations::HasManyThroughAssociation
+ parent_class=Feed,
+ child_class_name="Post",
+ target_name_symbol=:posts,
+ through_class=:blogs,
+ base_association=#<struct PassiveRecord::Associations::HasManyAssociation parent_class=Feed, child_class_name="Blog", children_name_sym=:blogs>,
+ habtm=false>
+
+We are constructing a query on `Post`, and want to say {blog: {feed_id: ...}} ...
+
+The through_class is :blogs which needs to be singularized
+
+---
+
+In the other case we are just trying to do `user.resources.where ...` ...
+
+=> #<struct PassiveRecord::Associations::HasManyThroughAssociation
+ parent_class=User,
+ child_class_name="Resource",
+ target_name_symbol=:resources,
+ through_class=:resource_allocations,
+ base_association=#<struct PassiveRecord::Associations::HasManyAssociation parent_class=User, child_class_name="ResourceAllocation", children_name_sym=:resource_allocations>,
+ habtm=false>
+
+We are constructing a query on `Resource` ...
+
+We need to check from the perspective of `Resource` what the relation is to allocations...?
+

data/spec/passive_record_spec.rb

@@ -562,6 +562,27 @@ describe "passive record models" do
       end
     end
 
+    context 'manual habtm' do
+      let!(:resource) { Resource.create }
+      let!(:user) { User.create }
+
+      it 'should permit relations' do
+        expect(user.resources).to be_empty
+        expect(resource.users).to be_empty
+
+        ResourceAllocation.create(user: user, resource: resource)
+
+        expect(user.resources).to include(resource)
+        expect(resource.users).to include(user)
+      end
+
+      it 'should permit querying' do
+        ResourceAllocation.create(user: user, resource: resource)
+        # binding.pry
+        expect(user.resources.where.all).to include(resource)
+      end
+    end
+
     context 'direct habtm' do
       before(:each) { PassiveRecord.drop_all }
       let!(:user) { User.create roles: [role] }

data/spec/spec_helper.rb

@@ -92,13 +92,28 @@ end
 class User < Model
   has_many :friendships
   has_many :friends, :through => :friendships
+
   has_and_belongs_to_many :roles
+
+  has_many :resource_allocations
+  has_many :resources, :through => :resource_allocations
 end
 
 class Role < Model
   has_and_belongs_to_many :users
 end
 
+class ResourceAllocation < Model
+  belongs_to :user
+  belongs_to :resource
+end
+
+class Resource < Model
+  # TODO why can't we use a custom class name here???
+  has_many :resource_allocations #, class_name: "ResourceAllocation"
+  has_many :users, through: :resource_allocations
+end
+
 ###
 #
 
@@ -161,7 +176,6 @@ class Post < Model
   end
 end
 
-# whoa, we're reopening user here -- this might not be expected
 class Author < Model
   has_many :posts
   has_many :comments

metadata

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