relaxdb 0.3.5 → 0.5

data/lib/relaxdb/has_one_proxy.rb

@@ -1,42 +0,0 @@
-module RelaxDB
-
-  class HasOneProxy
-  
-    def initialize(client, relationship)
-      @client = client
-      @relationship = relationship
-      @target_class = @relationship.to_s.camel_case      
-      @relationship_as_viewed_by_target = client.class.name.snake_case
-      
-      @target = nil
-    end
-    
-    def target
-      return @target if @target    
-      @target = load_target
-    end
-  
-    # All database changes performed by this method would ideally be done in a transaction
-    def target=(new_target)
-      # Nullify any existing relationship on assignment
-      old_target = target
-      if old_target
-        old_target.send("#{@relationship_as_viewed_by_target}=".to_sym, nil)
-        old_target.save
-      end
-    
-      @target = new_target
-      unless @target.nil?
-        @target.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
-        @target.save
-      end
-    end
-  
-    def load_target
-      view_name = "#{@client.class}_#{@relationship}"
-      RelaxDB.view(view_name, :key => @client._id).first
-    end
-        
-  end
-
-end

data/lib/relaxdb/references_many_proxy.rb

@@ -1,97 +0,0 @@
-module RelaxDB
-
-  class ReferencesManyProxy
-    
-    include Enumerable
-  
-    def initialize(client, relationship, opts)
-      @client = client
-      @relationship = relationship
-    
-      @target_class = opts[:class]
-      @relationship_as_viewed_by_target = opts[:known_as].to_s
-      
-      @peers = resolve
-    end
-  
-    def <<(obj, reciprocal_invocation=false)
-      return false if peer_ids.include? obj._id
-      
-      @peers << obj if @peers
-      peer_ids << obj._id
-    
-      unless reciprocal_invocation
-        # Set the other side of the relationship, ensuring this method isn't called again
-        obj.send(@relationship_as_viewed_by_target).send(:<<, @client, true) 
-    
-        # Bulk save to ensure relationship is persisted on both sides
-        RelaxDB.bulk_save! @client, obj
-      end
-    
-      self
-    end
-  
-    def clear
-      @peers.each do |peer|
-        peer.send(@relationship_as_viewed_by_target).send(:delete_from_self, @client)
-      end
-    
-      # Important to resolve in the database before in memory, although an examination of the
-      # contents of the bulk_save will look wrong as this object will still list all its peers
-      RelaxDB.bulk_save(@client, *@peers)
-      
-      peer_ids.clear
-      @peers.clear
-    end
-    
-    def delete(obj)
-      deleted = obj.send(@relationship_as_viewed_by_target).send(:delete_from_self, @client)
-      if deleted
-        delete_from_self(obj)
-        RelaxDB.bulk_save(@client, obj)
-      end
-      deleted
-    end
-  
-    def delete_from_self(obj)
-      @peers.delete(obj)
-      peer_ids.delete(obj._id)
-    end
-        
-    def empty?
-      peer_ids.empty?
-    end
-
-    def size
-      peer_ids.size
-    end
-  
-    def [](*args)
-      @peers[*args]
-    end
-  
-    def each(&blk)
-      @peers.each(&blk)    
-    end
-      
-    def inspect
-      @client.instance_variable_get("@#{@relationship}".to_sym).inspect
-    end
-      
-    def peer_ids
-      @client.instance_variable_get("@#{@relationship}".to_sym)
-    end
-  
-    alias to_id_a peer_ids
-  
-    private
-    
-    # Resolves the actual ids into real objects via a single GET to CouchDB
-    def resolve
-      view_name = "#{@client.class}_#{@relationship}"
-      @peers = RelaxDB.view(view_name, :key => @client._id)      
-    end
-    
-  end
-  
-end

data/spec/belongs_to_spec.rb

@@ -1,124 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-require File.dirname(__FILE__) + '/spec_models.rb'
-
-describe RelaxDB::BelongsToProxy do
-  
-  before(:all) do
-    setup_test_db
-  end
-
-  describe "belongs_to" do
-  
-    it "should return nil when accessed before assignment" do
-      r = Rating.new
-      r.photo.should == nil
-    end
-
-    it "should be establishable via constructor attribute" do
-      p = Photo.new
-      r = Rating.new :photo => p
-      r.photo.should == p
-    end
-    
-    it "should be establishable via constructor id" do
-      p = Photo.new.save
-      r = Rating.new(:photo_id => p._id).save
-      r.photo.should == p
-    end        
-      
-    it "should establish the parent relationship when supplied a parent and saved" do
-      p = Photo.new.save
-      r = Rating.new
-      r.photo = p
-      # I'm not saying the following is correct or desired - merely codifying how things stand 
-      p.rating.should be_nil 
-      r.save
-      p.rating.should == r
-    end    
-  
-    it "should establish the parent relationship when supplied a parent id and saved" do
-      p = Photo.new.save
-      r = Rating.new(:photo_id => p._id).save
-      p.rating.should == r
-    end        
-
-    it "should return the same object on repeated invocations" do
-      p = Photo.new.save
-      r = Rating.new(:photo => p).save
-      r = RelaxDB.load(r._id)
-      r.photo.object_id.should == r.photo.object_id
-    end    
-
-    it "should be nullified when the parent is destroyed" do
-      r = Rating.new
-      p = Photo.new(:rating => r).save
-      p.destroy!
-      RelaxDB.load(r._id).photo.should be_nil
-    end
-  
-    it "should be preserved across save / load boundary" do
-      r = Rating.new
-      p = Photo.new(:rating => r).save
-      r = RelaxDB.load r._id
-      r.photo.should == p
-    end    
-
-    it "should be able to reference itself via its parent" do
-      r = Rating.new
-      p = Photo.new(:rating => r).save
-      r = RelaxDB.load r._id
-      r.photo.rating.should == r
-    end    
-    
-    it "may be used reciprocally" do
-      C1 = Class.new(RelaxDB::Document) do
-        belongs_to :c2
-      end
-      C2 = Class.new(RelaxDB::Document) do
-        belongs_to :c1
-      end
-      i1, i2 = C1.new, C2.new
-
-      i1.c2 = i2
-      i1.save!
-      i2.c1 = i1
-      i2.save!
-      
-      i1 = RelaxDB.load i1._id
-      i1.c2.should == i2
-      
-      i2 = RelaxDB.load i2._id
-      i2.c1.should == i1
-    end
-    
-    describe "validator" do
-      
-      it "should be passed the _id and object" do
-        a = Atom.new(:_id => "atom").save!
-        c = Class.new(RelaxDB::Document) do
-          belongs_to :foo, :validator => lambda { |foo_id, obj| foo_id.reverse == obj._id }
-        end
-        c.new(:_id => "mota", :foo => a).save!
-      end
-      
-      it "may be used with a predefined validator" do
-        c = Class.new(RelaxDB::Document) do
-          belongs_to :foo, :validator => :required
-        end
-        c.new.save.should be_false
-      end
-
-      it "should be provided with a default error message when validation fails" do
-        c = Class.new(RelaxDB::Document) do
-          belongs_to :foo, :validator => :required
-        end
-        x = c.new
-        x.save
-        x.errors[:foo].should_not be_blank
-      end
-          
-    end
-    
-  end
-
-end

data/spec/has_many_spec.rb

@@ -1,202 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-require File.dirname(__FILE__) + '/spec_models.rb'
-
-describe RelaxDB::HasManyProxy do
-  
-  before(:all) do
-    setup_test_db
-  end
-
-  describe "has_many" do
-
-
-    describe "target_class in the generated view" do
-      it "should infer the class name from the relationship if not supplied" do
-        view = mock(:view).as_null_object
-        RelaxDB::ViewCreator.should_receive(:has_n).with(
-          "",           # client_class
-          :foo_bars,    # relationship          
-          "FooBar",     # target_class
-          ""            # relationship_to_client
-        ).and_return view
-        klass = Class.new(RelaxDB::Document) do
-          has_many :foo_bars
-        end
-      end 
-
-      it "should use the class name if supplied" do
-        view = mock(:view).as_null_object
-        RelaxDB::ViewCreator.should_receive(:has_n).with(
-          "",         # client_class
-          :foo_bars,  # relationship          
-          "Bar",     # target_class
-          ""          # relationship_to_client
-        ).and_return view
-        klass = Class.new(RelaxDB::Document) do
-          has_many :foo_bars, :class => "Bar"
-        end
-      end 
-    end    
-    
-    it "should be considered enumerable" do
-      u = User.new.save
-      u.items.should be_a_kind_of(Enumerable)
-    end
-    
-    it "should actually be enumerable" do
-      u = User.new.save
-      u.items << Item.new(:name => "a")
-      u.items << Item.new(:name => "b")
-      names = u.items.inject("") { |memo, i| memo << i.name }
-      names.should == "ab"
-    end
-    
-    it "should preserve the collection across the load / save boundary" do
-      u = User.new.save
-      u.items << Item.new
-      u = RelaxDB.load u._id
-      u.items.size.should == 1
-    end    
-    
-    it "should work with MultiWordClassNames" do
-      c = MultiWordChild.new
-      m = MultiWordClass.new.save
-      m.multi_word_children << c
-      m = RelaxDB.load m._id
-      m.multi_word_children[0].should == c
-    end    
-            
-    describe "#<<" do
-
-      it "should link the added item to the parent" do
-        u = User.new
-        u.items << Item.new
-        u.items[0].user.should == u
-      end
-    
-      it "should return self" do
-        u = User.new.save
-        u.items << Item.new << Item.new
-        u.items[0].user.should == u
-        u.items[1].user.should == u
-      end
-      
-      it "should not created duplicates when invoked with same object more than once" do
-        u = User.new.save
-        i = Item.new
-        u.items << i << i
-        u.items.size.should == 1
-      end
-      
-      it "should return false when the child fails validation" do
-        d = Dysfunctional.new
-        r = (d.failures << Failure.new)
-        r.should be_false
-        d.failures.should be_empty
-      end
-              
-    end
-    
-    describe "#=" do
-      
-      before(:each) do
-        # Create the underlying views
-        User.new(:items => [], :invites_received => [], :invites_sent => [])
-      end
-      
-      it "should not attempt to save the child objects when the relationship is established" do
-        RelaxDB.db.put_count = 0
-        i1, i2 = Item.new(:name => "i1"), Item.new(:name => "i2")
-        User.new(:items => [i1, i2])
-        RelaxDB.db.put_count.should == 0
-      end
-      
-      it "should preserve given relationships across save/load boundary" do
-        i1, i2 = Item.new(:name => "i1"), Item.new(:name => "i2")
-        u = User.new(:items => [i1, i2])
-        RelaxDB.bulk_save u, *u.items
-        u = RelaxDB.load u._id
-        u.items.map { |i| i.name }.sort.join.should == "i1i2"
-      end
-      
-      it "should invoke the derived properties writer" do
-        class HmsdParent < RelaxDB::Document
-          property :foo, :derived => [:zongs, lambda {|f, o| o.zongs.first.z / 2 }]
-          has_many :zongs, :class => "HmsdChild"
-        end
-        class HmsdChild < RelaxDB::Document
-          property :z
-          belongs_to :hmsd_parent
-        end
-        oz = HmsdChild.new(:z => 10)
-        op = HmsdParent.new(:zongs => [oz])
-        op.foo.should == 5
-      end
-      
-    end
-
-    describe "#delete" do
-    
-      it "should nullify the belongs_to relationship" do
-        u = User.new.save
-        i = Item.new
-        u.items << i
-        u.items.delete i
-        i.user.should be_nil 
-        RelaxDB.load(i._id).user.should be_nil
-      end
-    
-    end
-    
-    describe "#clear" do
-    
-      it "should result in an empty collection" do
-        u = User.new.save
-        u.items << Item.new << Item.new
-        u.items.clear
-        u.items.should be_empty
-      end
-
-      it "should nullify all child relationships" do
-        u = User.new.save
-        i1, i2 = Item.new, Item.new
-        u.items << i1
-        u.items << i2
-        u.items.clear
-
-        i1.user.should be_nil
-        i2.user.should be_nil
-        RelaxDB.load(i1._id).user.should be_nil
-        RelaxDB.load(i2._id).user.should be_nil
-      end
-    
-    end
-        
-    describe "owner" do
-    
-      it "should be able to form multiple relationships with the same class of child" do
-        u1, u2 = User.new.save, User.new.save
-        i = Invite.new(:recipient => u2)
-        u1.invites_sent << Invite.new
-        RelaxDB.load(u1._id).invites_sent[0] == i
-        RelaxDB.load(u2._id).invites_received[0] == i
-      end
-      
-      describe "#destroy" do
-
-        it "should nullify its child relationships" do
-          Item.view_by :user_id
-          
-          u = User.new.save
-          u.items << Item.new << Item.new    
-          u.destroy!
-          Item.by_user_id(:key => u._id).should be_empty
-        end
-
-      end  
-      
-    end
-              
-  end
-
-end