passive_record 0.3.12 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4039b8d12724a5b35a9414df1e44f7dfd0263e28
-  data.tar.gz: 28e9e7d6b5f34e5b08dedcb0e36fd5d8bd410347
+  metadata.gz: de382da8a3a2ab040066d8602ae28c3949c53d63
+  data.tar.gz: 91c7c31efa8ba22d39dbe0197c6260b5021e48b3
 SHA512:
-  metadata.gz: 676f9bc4c0e6975838d1a81c8b74651c5da6db0cc5eefa609d4b7516d79ff653cca7f9b98a6dbbd3c6d0d89871bbb0c35447af3831f758695bf86ac0a3f29039
-  data.tar.gz: 84179cc3fe391e30022cf6eedb23331dc3306e1fcba08cdfcf61b0c16680e8e196499c39fd75fb83284ce2f459a59bae35ad663ef3820a195d38111363d334b7
+  metadata.gz: 7e90366ff1718151ab079032aa41755c40f1bfb68c8fcedc45f58804f26f728405b840d2e3a82043b92de2afdbb7a2fe21999bd099eaa41632941df77ee3e183
+  data.tar.gz: be96a58c45ac7cef2f498a6e0738ab4b1ed8f2119f904442a3c392a7cccb0be7b5e9661aa29db6df08c8042e437dbe76dc9fb72fe509dc290977e3b2e53e50b5

data/lib/passive_record/associations.rb

@@ -87,7 +87,7 @@ module PassiveRecord
         through_class_collection_name = opts.delete(:through)
 
         through_class_name = (through_class_collection_name.to_s).split('_').map(&:capitalize).join
-        base_association = associations.detect { |assn| assn.child_class_name == through_class_name }
+        base_association = associations.detect { |assn| assn.child_class_name == through_class_name rescue false }
 
         association = HasManyThroughAssociation.new(
           self, target_class_name, collection_name_sym, through_class_collection_name, base_association)
@@ -141,6 +141,7 @@ module PassiveRecord
 
       define_method(:"create_#{collection_name_sym.to_s.singularize}") do |attrs={}|
         relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        # binding.pry
         relation.create(attrs)
       end
     end
@@ -155,13 +156,17 @@ module PassiveRecord
         self.name.split('::').last.singularize +
         "JoinModel"
 
-      if (Object.const_get(inverse_habtm_join_class_name) rescue false)
+      module_name = self.name.deconstantize
+      module_name = "Object" if module_name.empty?
+      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
       else
         auto_collection_sym = self.name.split('::').last.underscore.pluralize.to_sym
         eval <<-ruby
-        class ::#{habtm_join_class_name}                        # class UserRoleJoinModel
+        class #{module_name}::#{habtm_join_class_name}          # class System::UserRoleJoinModel
           include PassiveRecord                                 #   include PassiveRecord
           belongs_to :#{collection_name_sym.to_s.singularize}   #   belongs_to :role
           belongs_to :#{auto_collection_sym.to_s.singularize}   #   belongs_to :user

data/lib/passive_record/associations/belongs_to.rb

@@ -6,7 +6,14 @@ module PassiveRecord
       end
 
       def parent_class
-        Object.const_get(parent_class_name)
+        # look in same namespace as child 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
+        child_class.name
       end
     end
 

data/lib/passive_record/associations/has_many_through.rb

@@ -9,14 +9,40 @@ module PassiveRecord
     class HasManyThroughRelation < HasManyRelation
       def <<(child)
         intermediary_relation.
-          where((target_sym.to_s.singularize + "_id").to_sym => child.id).
+          where(
+            association.target_name_symbol.to_s.singularize + "_id" => child.id).
           first_or_create
-        all
+        self
+      end
+
+      def create(attrs={})
+        child = child_class.create(attrs)
+        send(:<<, child)
+        child
+      end
+
+      def nested_class
+        module_name = association.parent_class.name.deconstantize
+        module_name = "Object" if module_name.empty?
+        (module_name.constantize).
+          const_get("#{association.base_association.child_class_name.singularize}")
+      end
+
+      def nested_association
+        nested_class.associations.detect { |assn|
+          assn.child_class_name == association.child_class_name ||
+          assn.child_class_name == association.child_class_name.singularize ||
+
+          (assn.parent_class_name == association.child_class_name rescue false) ||
+          (assn.parent_class_name == association.child_class_name.singularize rescue false) ||
+
+          assn.target_name_symbol == association.target_name_symbol.to_s.singularize.to_sym
+        }
       end
 
       def all
-        if target_sym && results
-          final_results = results.flat_map(&target_sym)
+        if intermediate_results && !intermediate_results.empty?
+          final_results = intermediate_results.flat_map(&nested_association.target_name_symbol)
           if final_results.first.is_a?(Associations::Relation) && !final_results.first.singular?
             final_results.first.send(:all)
           else
@@ -27,39 +53,13 @@ module PassiveRecord
         end
       end
 
-
       def intermediary_relation
         association.base_association.to_relation(parent_model)
       end
 
-      def results
+      def intermediate_results
         intermediary_relation.all
       end
-
-      def target_sym
-        name_str = association.target_name_symbol.to_s
-        singular_target_sym = name_str.singularize.to_sym
-        plural_target_sym   = name_str.pluralize.to_sym
-
-        singular_class_name_sym = association.child_class_name.underscore.singularize.to_sym
-        plural_class_name_sym = association.child_class_name.underscore.pluralize.to_sym
-
-        if !results.empty?
-          if results.first.respond_to?(singular_target_sym)
-            singular_target_sym
-          elsif results.first.respond_to?(plural_target_sym)
-            plural_target_sym
-          elsif results.first.respond_to?(singular_class_name_sym)
-            singular_class_name_sym
-          elsif results.first.respond_to?(plural_class_name_sym)
-            plural_class_name_sym
-          end
-        end
-      end
-
-      def create(attrs={})
-        child_class.create(attrs)
-      end
     end
   end
 end

data/lib/passive_record/associations/has_one.rb

@@ -30,20 +30,24 @@ module PassiveRecord
       end
 
       def parent_model_id_field
-        parent_class_name + "_id"
-      end
-
-      def parent_class_name
-        association.parent_class.name.split('::').last.underscore
+        association.parent_class.name.demodulize.underscore + "_id"
       end
 
       def child_class
-        Object.const_get(association.child_class_name.singularize)
+        # look in same module as parent...
+	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
         parent_model.id
       end
+
+      def child_class_name
+        child_class.name
+      end
     end
   end
 end

data/lib/passive_record/instance_methods.rb

@@ -44,7 +44,7 @@ module PassiveRecord
       attr_names = instance_variables
       attr_names += self.class.associations_id_syms
       attr_names += members rescue []
-      attr_names.reject! { |name| name.to_s.start_with?("@_") }
+      attr_names.reject! { |name| name.to_s.start_with?("@_") || name.match(/join_model/) }
       attr_names - blacklisted_attribute_names
     end
 

data/lib/passive_record/version.rb

@@ -1,4 +1,4 @@
 module PassiveRecord
   # passive_record version
-  VERSION = "0.3.12"
+  VERSION = "0.3.13"
 end

data/spec/passive_record_spec.rb

@@ -55,17 +55,17 @@ describe "passive record models" do
         end
 
         it 'should report relations' do
-          dog = Dog.create
+          dog = Family::Dog.create
           expect(dog.inspect).
             to eq("Family::Dog (id: #{dog.id.inspect}, breed: \"#{dog.breed}\", created_at: #{dog.created_at}, sound: \"bark\", child_id: nil)")
 
-          child = Child.create
+          child = Family::Child.create
           child.dogs << dog
           expect(dog.inspect).
             to eq("Family::Dog (id: #{dog.id.inspect}, breed: \"#{dog.breed}\", created_at: #{dog.created_at}, sound: \"bark\", child_id: #{child.id.inspect})")
 
           expect(child.inspect).
-            to eq("Family::Child (id: #{child.id.inspect}, created_at: #{child.created_at}, name: \"Alice\", toy_id: nil, dog_ids: [#{dog.id.inspect}], parent_id: nil)")
+            to eq("Family::Child (id: #{child.id.inspect}, created_at: #{child.created_at}, name: \"Alice\", toy_id: nil, dog_ids: [#{dog.id.inspect}], parent_id: nil, secret_club_ids: [])")
         end
       end
 
@@ -238,27 +238,27 @@ describe "passive record models" do
   context 'hooks' do
     context 'after create hooks' do
       it 'should use a symbol to invoke a method' do
-        expect(Child.create.name).to eq("Alice")
+        expect(Family::Child.create.name).to eq("Alice")
       end
 
       it 'should use a block' do
-        expect(Dog.create.sound).to eq("bark")
+        expect(Family::Dog.create.sound).to eq("bark")
       end
 
       it 'should use an inherited block' do
-        expect(Parent.create.created_at).to be_a(Time)
+        expect(Family::Parent.create.created_at).to be_a(Time)
       end
     end
   end
 
   context 'associations' do
     context 'one-to-one relationships' do
-      let(:child) { Child.create }
-      let(:another_child) { Child.create }
+      let(:child) { Family::Child.create }
+      let(:another_child) { Family::Child.create }
 
       it 'should create children' do
-        expect { child.create_toy }.to change { Toy.count }.by(1)
-        expect(child.toy).to eq(Toy.last)
+        expect { child.create_toy }.to change { Family::Toy.count }.by(1)
+        expect(child.toy).to eq(Family::Toy.last)
       end
 
       it 'should have inverse relationships' do
@@ -270,23 +270,23 @@ describe "passive record models" do
       end
 
       it 'should assign parents' do
-        toy = Toy.create
+        toy = Family::Toy.create
         toy.child = child
         expect(child.toy).to eq(toy)
 
-        child.toy = Toy.create
+        child.toy = Family::Toy.create
         expect(child.toy).not_to eq(toy)
       end
     end
 
     context 'one-to-many relationships' do
-      let(:parent) { Parent.create }
-      let(:another_parent) { Parent.create(children: [another_child]) }
-      let(:another_child) { Child.create }
+      let(:parent) { Family::Parent.create }
+      let(:another_parent) { Family::Parent.create(children: [another_child]) }
+      let(:another_child) { Family::Child.create }
 
       describe "#xxx<<" do
         it 'should create children with <<' do
-          child = Child.create
+          child = Family::Child.create
           expect {parent.children << child}.to change{parent.children.count}.by(1)
           expect(parent.children).to include(child)
         end
@@ -294,8 +294,8 @@ describe "passive record models" do
 
       describe "#create_xxx" do
         it 'should create children' do
-          expect { parent.create_child }.to change{ Child.count }.by(1)
-          expect(parent.children).to all(be_a(Child))
+          expect { parent.create_child }.to change{ Family::Child.count }.by(1)
+          expect(parent.children).to all(be_a(Family::Child))
         end
       end
 
@@ -317,32 +317,33 @@ describe "passive record models" do
     end
 
     context 'one-to-many through relationships' do
-      let(:parent) { Parent.create }
+      let(:parent) { Family::Parent.create }
       let(:child) { parent.create_child }
 
       it 'should collect children of children' do
         child.create_dog(breed: 'mutt')
-        expect(parent.dogs.all).to all(be_a(Dog))
+        expect(parent.dogs.all).to all(be_a(Family::Dog))
         expect(parent.dogs.count).to eq(1)
         expect(parent.dogs.first).to eq(child.dogs.first)
         expect(parent.dog_ids).to eq([child.dogs.first.id])
       end
 
       it 'should chain where clauses' do
-        child.create_dog(breed: 'mutt')
-        child.create_dog(breed: 'pit')
+        mutt = child.create_dog(breed: 'mutt')
+        pit = child.create_dog(breed: 'pit')
 
         # another mutt, not the same childs
-        Dog.create(breed: 'mutt')
+        another_mutt = Family::Dog.create(breed: 'mutt')
 
-        expect(Dog.where(breed: 'mutt').count).to eq(2)
-        expect(child.dogs.where(breed: 'mutt').count).to eq(1)
+        expect(Family::Dog.where(breed: 'mutt').all).to eq([mutt, another_mutt])
+        expect(child.dogs.where(breed: 'mutt').all).to eq([mutt])
+        expect(child.dogs.where.not(breed: 'mutt').all).to eq([pit])
 
         expect(
           child.dogs.
             where(breed: 'mutt')
         ).to eq(
-          Dog.
+          Family::Dog.
             where(child_id: child.id).
             where(breed: 'mutt')
         )
@@ -350,27 +351,28 @@ describe "passive record models" do
 
       it 'should do the nested query example from the readme' do
         child.create_dog
-        expect(Dog.find_all_by(child: {parent: parent})).
+        expect(Family::Dog.find_all_by(child: {parent: parent})).
           to eq(parent.dogs.all)
       end
 
       it 'should work for has-one intermediary relationships' do
         child.create_toy
-        expect(parent.toys).to all(be_a(Toy))
+        expect(parent.toys).to all(be_a(Family::Toy))
         expect(parent.toys.count).to eq(1)
         expect(parent.toys.first).to eq(child.toy)
       end
 
       it 'should attempt to construct intermediary relations' do
-        expect { parent.create_toy(child: child) }.to change {Toy.count}.by(1)
-        expect(Toy.last.child).to eq(child)
-        expect(Toy.last.child.parent).to eq(parent)
+        expect { parent.create_toy(child: child) }.to change {Family::Toy.count}.by(1)
+        expect(Family::Toy.last.child).to eq(child)
+        expect(Family::Toy.last.child.parent).to eq(parent)
       end
 
       it 'should accept class name' do
         post = Post.create
         user = User.create
         Comment.create(post: post, user: user)
+
         expect(post.commenters.all).to eq([user])
       end
     end
@@ -422,14 +424,15 @@ describe "passive record models" do
       it 'should handle inverse relations' do
         expect {role.users << another_user}.to change{another_user.roles.count}.by(1)
       end
-    end
-  end
-end
 
-describe "configuration" do
-  context 'with default config' do
-    it 'should generate simple identifiers' do
-      expect(Model.create.id).to be_a(PassiveRecord::SecureRandomIdentifier)
+      it 'should work inside modules' do
+        child = Family::Child.create
+        secret_club = child.create_secret_club
+
+        expect(secret_club).to be_a(Family::SecretClub)
+        expect(secret_club.children.all).to eq([child])
+        expect(child.secret_clubs.first.create_child).to be_a(Family::Child)
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -36,6 +36,7 @@ module Family
     has_one :toy
     has_many :dogs
     belongs_to :parent
+    has_and_belongs_to_many :secret_clubs
 
     attr_reader :name
     after_create :give_name
@@ -43,13 +44,17 @@ module Family
     def give_name; @name = "Alice" end
   end
 
+  class SecretClub < Model
+    has_and_belongs_to_many :children
+  end
+
   class Parent < Model
     has_many :children
     has_many :dogs, :through => :children
     has_many :toys, :through => :children
   end
 end
-include Family
+#include Family
 
 ###
 
@@ -90,18 +95,18 @@ end
 ###
 
 class Post < Model
-  has_many :comments 
+  has_many :comments
   has_many :commenters, :through => :comments, :class_name => "User"
 
   attr_accessor :published_at
   before_create { @published_at = Time.now }
 
   def self.recent
-    where(:published_at => 3.days.ago..Time.now) 
+    where(:published_at => 3.days.ago..Time.now)
   end
 
   def self.published_within_days(n)
-    where(:published_at => n.days.ago..Time.now) 
+    where(:published_at => n.days.ago..Time.now)
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passive_record
 version: !ruby/object:Gem::Version
-  version: 0.3.12
+  version: 0.3.13
 platform: ruby
 authors:
 - Joseph Weissman