amistad 0.5.8 → 0.6.0

data/CHANGELOG

@@ -1,3 +1,12 @@
+Version 0.6.0 (06.01.2011)
+--------------------------
+- improved blocking and unblocking friends
+- method is_friend_with? changed to friend_with?
+- method is_connected_with? changed to connected_with?
+- method was_invited_by? changed to invited_by?
+- method has_invited? changed to invited?
+- added method blocked?
+
 Version 0.5.8 (08.12.2010)
 --------------------------
 - made find_any_friendship_with public

data/README.markdown

@@ -82,22 +82,22 @@ To get the pending friendships use :
     
 It is also possible to check if two users are friends :
 
-    @john.is_friend_with? @jane #=> true
-    @victoria.is_friend_with? @john #=> false
+    @john.friend_with? @jane #=> true
+    @victoria.friend_with? @john #=> false
 
 You can also check if a user is somehow connected to another :
 
-    @john.is_connected_with? @jane #=> true
-    @victoria.is_connected_with? @john #=> true
+    @john.connected_with? @jane #=> true
+    @victoria.connected_with? @john #=> true
 
 You can also check if a user was invited by anoter :
 
-    @john.was_invited_by? @john #=> true
-    @victoria.was_invited_by? @john #=> false
+    @john.invited_by? @john #=> true
+    @victoria.invited_by? @john #=> false
 
 You can also check if a user invited another :
 
-    @john.has_invited? @jane #=> true
+    @john.invited? @jane #=> true
 
 You can also find the friends that two users have in common :
 
@@ -122,6 +122,10 @@ To get the blocked users :
 
     @jane.blocked #=> [@john]
 
+You can also check if a user is blocked :
+
+    @jane.blocked? @john #=> true
+
 ### Unblocking friendship ###
 
 The __unblock()__ method allow a user to unblock previously blocked friendship with another user :

data/amistad.gemspec

@@ -14,10 +14,10 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "amistad"
 
-  s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "rspec", "~> 2.2.0"
-  s.add_development_dependency "activerecord", "~> 3.0.0"
-  s.add_development_dependency "sqlite3-ruby", ">= 1.3.2"
+  s.add_development_dependency "bundler", "~>1.0.7"
+  s.add_development_dependency "rspec", "~> 2.4.0"
+  s.add_development_dependency "activerecord", "~> 3.0.3"
+  s.add_development_dependency "sqlite3-ruby", "1.3.2"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/amistad.rb

@@ -1,5 +1,2 @@
 require 'amistad/friend_model'
 require 'amistad/friendship_model'
-
-module Amistad
-end

data/lib/amistad/friend_model.rb

@@ -3,35 +3,42 @@ module Amistad
     def self.included(receiver)
       receiver.class_exec do
         include InstanceMethods
-        
+
         has_many  :friendships
-        
+
         has_many  :pending_invited,
                   :through => :friendships,
                   :source => :friend,
-                  :conditions => { :'friendships.pending' => true, :'friendships.blocked' => false }
-                  
+                  :conditions => { :'friendships.pending' => true, :'friendships.blocker_id' => nil }
+
         has_many  :invited,
                   :through => :friendships,
                   :source => :friend,
-                  :conditions => { :'friendships.pending' => false, :'friendships.blocked' => false }
+                  :conditions => { :'friendships.pending' => false, :'friendships.blocker_id' => nil }
 
         has_many  :inverse_friendships, :class_name => "Friendship", :foreign_key => "friend_id"
-        
+
         has_many  :pending_invited_by,
                   :through => :inverse_friendships,
                   :source => :user,
-                  :conditions => { :'friendships.pending' => true, :'friendships.blocked' => false }
-                  
+                  :conditions => { :'friendships.pending' => true, :'friendships.blocker_id' => nil }
+
         has_many  :invited_by,
                   :through => :inverse_friendships,
                   :source => :user,
-                  :conditions => { :'friendships.pending' => false, :'friendships.blocked' => false }
-                  
-        has_many  :blocked,
-                  :through => :inverse_friendships,
+                  :conditions => { :'friendships.pending' => false, :'friendships.blocker_id' => nil }
+
+        has_many  :blocked_friendships, :class_name => "Friendship", :foreign_key => "blocker_id"
+
+        has_many  :blockades,
+                  :through => :blocked_friendships,
+                  :source => :friend,
+                  :conditions => "friend_id <> blocker_id"
+
+        has_many  :blockades_by,
+                  :through => :blocked_friendships,
                   :source => :user,
-                  :conditions => { :'friendships.blocked' => true }
+                  :conditions => "user_id <> blocker_id"
       end
     end
 
@@ -41,70 +48,80 @@ module Amistad
         return false if user == self || find_any_friendship_with(user)
         Friendship.new(:user_id => self.id, :friend_id => user.id).save
       end
-      
+
       # approve a friendship invitation. If the operation succeeds, the method returns true, else false
       def approve(user)
         friendship = find_any_friendship_with(user)
-        return false if friendship.nil? || has_invited?(user)
+        return false if friendship.nil? || invited?(user)
         friendship.update_attribute(:pending, false)
       end
-      
+
+      # deletes a friendship
+      def remove(user)
+        friendship = find_any_friendship_with(user)
+        return false if friendship.nil?
+        friendship.destroy && friendship.destroyed?
+      end
+
       # returns the list of approved friends
       def friends
         self.invited(true) + self.invited_by(true)
       end
-      
-      # blocks a friendship request
+
+      # blocks a friendship
       def block(user)
         friendship = find_any_friendship_with(user)
-        return false if friendship.nil? || friendship.user == self
-        friendship.blocked = true
-        friendship.save
+        return false if friendship.nil? || !friendship.can_block?(self)
+        friendship.update_attribute(:blocker, self)
       end
 
       # unblocks a friendship
       def unblock(user)
         friendship = find_any_friendship_with(user)
-        return false if friendship.nil? || friendship.user == self
-        friendship.blocked = false
-        friendship.save
+        return false if friendship.nil? || !friendship.can_unblock?(self)
+        friendship.update_attribute(:blocker, nil)
       end
-      
-      # deletes a friendship
-      def remove(user)
-        friendship = find_any_friendship_with(user)
-        return false if friendship.nil?
-        friendship.destroy
-        friendship.destroyed?
+
+      # returns the list of blocked friends
+      def blocked
+        self.blockades(true) + self.blockades_by(true)
+      end
+
+      # checks if a user is blocked
+      def blocked?(user)
+        blocked.include?(user)
       end
-      
+
       # checks if a user is a friend
-      def is_friend_with?(user)
+      def friend_with?(user)
         friends.include?(user)
       end
 
-      def is_connected_with?(user)
-        !find_any_friendship_with(user).nil?
+      # checks if a current user is connected to given user
+      def connected_with?(user)
+        find_any_friendship_with(user).present?
       end
 
-      # checks if a user send a friendship's invitation
-      def was_invited_by?(user)
+      # checks if a current user received invitation from given user
+      def invited_by?(user)
         friendship = find_any_friendship_with(user)
         return false if friendship.nil?
         friendship.user == user
       end
 
-      def has_invited?(user)
+      # checks if a current user invited given user
+      def invited?(user)
         friendship = find_any_friendship_with(user)
         return false if friendship.nil?
         friendship.friend == user
       end
-      
+
       # return the list of the ones among its friends which are also friend with the given use
       def common_friends_with(user)
         self.friends & user.friends
       end
-          
+
+      # returns friendship with given user or nil
       def find_any_friendship_with(user)
         friendship = Friendship.where(:user_id => self.id, :friend_id => user.id).first
         if friendship.nil?

data/lib/amistad/friendship_model.rb

@@ -1,29 +1,48 @@
 module Amistad
   module FriendshipModel
-    
     def self.included(receiver)
       receiver.class_exec do
         include InstanceMethods
-        
+
         belongs_to :user
         belongs_to :friend, :class_name => "User", :foreign_key => "friend_id"
-        
+        belongs_to :blocker, :class_name => "User", :foreign_key => "blocker_id"
+
         validates_presence_of :user_id, :friend_id
         validates_uniqueness_of :friend_id, :scope => :user_id
       end
     end
-    
+
     module InstanceMethods
+      # returns true if a friendship has been approved, else false
+      def approved?
+        !self.pending
+      end
+
       # returns true if a friendship has not been approved, else false
       def pending?
         self.pending
       end
-      
+
       # returns true if a friendship has been blocked, else false
       def blocked?
-        self.blocked
+        self.blocker_id.present?
+      end
+
+      # returns true if a friendship has not beed blocked, else false
+      def active?
+        self.blocker_id.nil?
+      end
+
+      # returns true if a friendship can be blocked by given user
+      def can_block?(user)
+        active? && (approved? || (pending? && self.friend == user))
+      end
+
+      # returns true if a friendship can be unblocked by given user
+      def can_unblock?(user)
+        blocked? && self.blocker == user
       end
     end
-    
   end
 end

data/lib/amistad/version.rb

@@ -1,3 +1,3 @@
 module Amistad
-  VERSION = "0.5.8"
+  VERSION = "0.6.0"
 end

data/lib/generators/amistad/install/templates/create_friendships.rb

@@ -3,8 +3,8 @@ class CreateFriendships < ActiveRecord::Migration
     create_table :friendships do |t|
       t.integer :user_id
       t.integer :friend_id
+      t.integer :blocker_id
       t.boolean :pending, :default => true
-      t.boolean :blocked, :default => false
     end
 
     add_index :friendships, [:user_id, :friend_id], :unique => true

data/spec/friend_model_spec.rb

@@ -1,271 +1,394 @@
 require 'spec_helper'
 
 describe Amistad::FriendModel do
-  
+
   before(:all) do
-    %w(John Jane david James Peter Mary Victoria Elisabeth).each do |name|
-      eval "@#{name.downcase} = User.create(:name => '#{name}')"
+    %w(John Jane David James Peter Mary Victoria Elisabeth).each do |name|
+      instance_variable_set("@#{name.downcase}".to_sym, User.create(:name => name))
     end
   end
-  
+
   context "when creating friendships" do
-    before(:each) do
+    before do
       Friendship.delete_all
     end
-    
-    it "requests friendships with other users" do
-      @john.invite(@jane).should == true
-      @victoria.invite(@john).should == true
+
+    it "should invite other users to friends" do
+      @john.invite(@jane).should be_true
+      @victoria.invite(@john).should be_true
     end
 
-    it "approves friendships requested by other users" do
-      @john.invite(@jane).should == true
-      @victoria.invite(@john).should == true
+    it "should approve only friendships requested by other users" do
+      @john.invite(@jane).should be_true
+      @jane.approve(@john).should be_true
+      @victoria.invite(@john).should be_true
+      @john.approve(@victoria).should be_true
+    end
 
-      @jane.approve(@john).should == true
-      @john.approve(@victoria).should == true
+    it "should not invite an already invited user" do
+      @john.invite(@jane).should be_true
+      @john.invite(@jane).should be_false
+      @jane.invite(@john).should be_false
     end
 
-    it "could not create a new friendship with a user which is already a friend" do
-      @john.invite(@jane).should == true
-      @john.invite(@jane).should == false
-      @jane.invite(@john).should == false
+    it "should not invite an already approved user" do
+      @john.invite(@jane).should be_true
+      @jane.approve(@john).should be_true
+      @jane.invite(@john).should be_false
+      @john.invite(@jane).should be_false
     end
 
-    it "could not approve self requested friendship" do
-      @john.invite(@jane).should == true
-      @victoria.invite(@john).should == true
+    it "should not invite an already blocked user" do
+      @john.invite(@jane).should be_true
+      @jane.block(@john).should be_true
+      @jane.invite(@john).should be_false
+      @john.invite(@jane).should be_false
+    end
 
-      @john.approve(@jane).should == false
-      @victoria.approve(@john).should == false
+    it "should not approve a self requested friendship" do
+      @john.invite(@jane).should be_true
+      @john.approve(@jane).should be_false
+      @victoria.invite(@john).should be_true
+      @victoria.approve(@john).should be_false
     end
 
-    it "could not create a friendship with himself" do
-      @john.invite(@john).should == false
+    it "should not create a friendship with himself" do
+      @john.invite(@john).should be_false
     end
-    
-    it "could not approuve a non-existent friendship" do
-      @peter.approve(@john).should == false
+
+    it "should not approve a non-existent friendship" do
+      @peter.approve(@john).should be_false
     end
   end
-  
+
   context "when listing friendships" do
-    before(:each) do
+    before do
       Friendship.delete_all
+      @john.invite(@jane).should be_true
+      @peter.invite(@john).should be_true
+      @john.invite(@james).should be_true
+      @james.approve(@john).should be_true
+      @mary.invite(@john).should be_true
+      @john.approve(@mary).should be_true
+    end
 
-      @john.invite(@jane).should == true
-      @john.invite(@james).should == true
-      
-      @peter.invite(@john).should == true
-      @mary.invite(@john).should == true
-      
-      @james.approve(@john).should == true
-      @john.approve(@mary).should == true
+    it "should list all the friends" do
+      @john.friends.should =~ [@mary, @james]
     end
-    
-    it "lists all the friends" do
-      @john.friends.count.should == 2
-      @john.friends.should include(@james)
-      @john.friends.should include(@mary)
+
+    it "should not list non-friended users" do
+      @john.friends.should =~ [@mary, @james]
+      @john.friends.should_not include(@peter)
+      @john.friends.should_not include(@victoria)
     end
-    
-    it "lists the friends who invited him" do
-      @john.invited_by.should include(@mary)
-      @john.invited_by.should_not include(@peter)
+
+    it "should list the friends who invited him" do
+      @john.invited_by.should == [@mary]
     end
-    
-    it "lists the friends who was invited by him" do
-      @john.invited.should include(@james)
-      @john.invited.should_not include(@jane)
+
+    it "should list the friends who were invited by him" do
+      @john.invited.should == [@james]
     end
-    
-    it "lists the pending friends who invited him" do
-      @john.pending_invited_by.should_not include(@mary)
-      @john.pending_invited_by.should include(@peter)
+
+    it "should list the pending friends who invited him" do
+      @john.pending_invited_by.should == [@peter]
     end
 
-    it "lists the pending friends who was invited by him" do
-      @john.pending_invited.should_not include(@james)
-      @john.pending_invited.should include(@jane)
+    it "should list the pending friends who were invited by him" do
+      @john.pending_invited.should == [@jane]
     end
 
-    it "checks if a user is a friend" do
-      @john.is_friend_with?(@james).should == true
-      @john.is_friend_with?(@mary).should == true
+    it "should list the friends he has in common with another user" do
+      @james.common_friends_with(@mary).should == [@john]
+    end
 
-      @john.is_friend_with?(@jane).should == false
-      @john.is_friend_with?(@peter).should == false
+    it "should not list the friends he does not have in common" do
+      @john.common_friends_with(@mary).count.should == 0
+      @john.common_friends_with(@mary).should_not include(@james)
+      @john.common_friends_with(@peter).count.should == 0
+      @john.common_friends_with(@peter).should_not include(@jane)
     end
 
-    it "checks if a user has any connection with another user" do
-      @john.is_connected_with?(@jane).should == true
-      @jane.is_connected_with?(@john).should == true
+    it "should check if a user is a friend" do
+      @john.friend_with?(@mary).should be_true
+      @mary.friend_with?(@john).should be_true
+      @john.friend_with?(@james).should be_true
+      @james.friend_with?(@john).should be_true
+    end
 
-      @john.is_connected_with?(@peter).should == true
-      @peter.is_connected_with?(@john).should == true
+    it "should check if a user is not a friend" do
+      @john.friend_with?(@jane).should be_false
+      @jane.friend_with?(@john).should be_false
+      @john.friend_with?(@peter).should be_false
+      @peter.friend_with?(@john).should be_false
+    end
 
-      @victoria.is_connected_with?(@john).should == false
-      @john.is_connected_with?(@victoria).should == false
+    it "should check if a user has any connections with another user" do
+      @john.connected_with?(@jane).should be_true
+      @jane.connected_with?(@john).should be_true
+      @john.connected_with?(@peter).should be_true
+      @peter.connected_with?(@john).should be_true
     end
 
-    it "checks if a user was invited by another" do
-      @jane.was_invited_by?(@john).should == true
-      @james.was_invited_by?(@john).should == true
-      
-      @john.was_invited_by?(@jane).should == false
-      @victoria.was_invited_by?(@john).should == false
+    it "should check if a user does not have any connections with another user" do
+      @victoria.connected_with?(@john).should be_false
+      @john.connected_with?(@victoria).should be_false
     end
 
-    it "checks if a user has invited another user" do
-      @john.has_invited?(@jane).should == true
-      @john.has_invited?(@james).should == true
+    it "should check if a user was invited by another" do
+      @jane.invited_by?(@john).should be_true
+      @james.invited_by?(@john).should be_true
+    end
 
-      @jane.has_invited?(@john).should == false
-      @james.has_invited?(@john).should == false
+    it "should check if a user was not invited by another" do
+      @john.invited_by?(@jane).should be_false
+      @victoria.invited_by?(@john).should be_false
+    end
 
-      @victoria.has_invited?(@john).should == false
-      @john.has_invited?(@victoria).should == false
+    it "should check if a user has invited another user" do
+      @john.invited?(@jane).should be_true
+      @john.invited?(@james).should be_true
     end
 
-    it "lists the friends he has in common with another user" do
-      @james.common_friends_with(@mary).count.should == 1
-      @james.common_friends_with(@mary).should include(@john)
+    it "should check if a user did not invite another user" do
+      @jane.invited?(@john).should be_false
+      @james.invited?(@john).should be_false
+      @john.invited?(@victoria).should be_false
+      @victoria.invited?(@john).should be_false
     end
   end
-  
+
   context "when removing friendships" do
-    before(:each) do
+    before do
       Friendship.delete_all
+      @jane.invite(@james).should be_true
+      @james.approve(@jane).should be_true
+      @james.invite(@victoria).should be_true
+      @victoria.approve(@james).should be_true
+      @victoria.invite(@mary).should be_true
+      @mary.approve(@victoria).should be_true
+      @victoria.invite(@john).should be_true
+      @john.approve(@victoria).should be_true
+      @peter.invite(@victoria).should be_true
+      @victoria.invite(@elisabeth).should be_true
+    end
 
-      @victoria.invite(@mary).should == true
-      @victoria.invite(@john).should == true
-      @victoria.invite(@elisabeth).should == true
-      
-      @james.invite(@victoria).should == true
-      @peter.invite(@victoria).should == true
-      @jane.invite(@victoria).should == true
-      
-      @mary.approve(@victoria).should == true
-      @john.approve(@victoria).should == true
-      @victoria.approve(@james).should == true
-      @victoria.approve(@jane).should == true
-    end
-    
-    it "removes the friends invited by him" do
-      @victoria.remove(@mary).should == true
-      
-      @victoria.invited.count.should == 1
-      @victoria.invited.should include(@john)
+    it "should remove the friends invited by him" do
+      @victoria.friends.size.should == 3
+      @victoria.friends.should include(@mary)
+      @victoria.invited.should include(@mary)
+      @mary.friends.size.should == 1
+      @mary.friends.should include(@victoria)
+      @mary.invited_by.should include(@victoria)
+      @victoria.remove(@mary).should be_true
+      @victoria.friends.size.should == 2
       @victoria.friends.should_not include(@mary)
-      
-      @mary.invited_by.should_not include(@victoria)
+      @victoria.invited.should_not include(@mary)
+      @mary.friends.size.should == 0
       @mary.friends.should_not include(@victoria)
+      @mary.invited_by.should_not include(@victoria)
     end
-    
-    it "removes the friends who invited him" do
-      @victoria.remove(@james).should == true
-      
-      @victoria.invited_by.count.should == 1
-      @victoria.invited_by.should include(@jane)
+
+    it "should remove the friends who invited him" do
+      @victoria.friends.size.should == 3
+      @victoria.friends.should include(@james)
+      @victoria.invited_by.should include(@james)
+      @james.friends.size.should == 2
+      @james.friends.should include(@victoria)
+      @james.invited.should include(@victoria)
+      @victoria.remove(@james).should be_true
+      @victoria.friends.size.should == 2
       @victoria.friends.should_not include(@james)
-      
-      @james.invited.should_not include(@victoria)
+      @victoria.invited_by.should_not include(@james)
+      @james.friends.size.should == 1
       @james.friends.should_not include(@victoria)
+      @james.invited.should_not include(@victoria)
     end
-    
-    it "removes the pending friends invited by him" do
-      @victoria.remove(@elisabeth).should == true
-      @victoria.pending_invited.count.should == 0
+
+    it "should remove the pending friends invited by him" do
+      @victoria.pending_invited.size.should == 1
+      @victoria.pending_invited.should include(@elisabeth)
+      @elisabeth.pending_invited_by.size.should == 1
+      @elisabeth.pending_invited_by.should include(@victoria)
+      @victoria.remove(@elisabeth).should be_true
+      [@victoria, @elisabeth].map(&:reload)
+      @victoria.pending_invited.size.should == 0
+      @victoria.pending_invited.should_not include(@elisabeth)
+      @elisabeth.pending_invited_by.size.should == 0
       @elisabeth.pending_invited_by.should_not include(@victoria)
     end
-    
-    it "removes the pending friends who invited him" do
-      @victoria.remove(@peter).should == true
+
+    it "should remove the pending friends who invited him" do
+      @victoria.pending_invited_by.count.should == 1
+      @victoria.pending_invited_by.should include(@peter)
+      @peter.pending_invited.count.should == 1
+      @peter.pending_invited.should include(@victoria)
+      @victoria.remove(@peter).should be_true
+      [@victoria, @peter].map(&:reload)
       @victoria.pending_invited_by.count.should == 0
+      @victoria.pending_invited_by.should_not include(@peter)
+      @peter.pending_invited.count.should == 0
       @peter.pending_invited.should_not include(@victoria)
     end
   end
-  
+
   context "when blocking friendships" do
-    before(:each) do
+    before do
       Friendship.delete_all
+      @john.invite(@james).should be_true
+      @james.approve(@john).should be_true
+      @james.block(@john).should be_true
+      @mary.invite(@victoria).should be_true
+      @victoria.approve(@mary).should be_true
+      @victoria.block(@mary).should be_true
+      @victoria.invite(@david).should be_true
+      @david.block(@victoria).should be_true
+      @john.invite(@david).should be_true
+      @david.block(@john).should be_true
+      @peter.invite(@elisabeth).should be_true
+      @elisabeth.block(@peter).should be_true
+      @jane.invite(@john).should be_true
+      @jane.invite(@james).should be_true
+      @james.approve(@jane).should be_true
+      @victoria.invite(@jane).should be_true
+      @victoria.invite(@james).should be_true
+      @james.approve(@victoria).should be_true
+    end
 
-      @john.invite(@jane).should == true
-      @john.invite(@james).should == true
-      @john.invite(@david).should == true
-      @james.approve(@john).should == true
-      @david.block(@john).should == true
-      @david.block(@victoria).should == false
-    end
-    
-    it "should allow to block only invited user" do
-      @jane.block(@john).should == true
-      @john.block(@jane).should == false
-    end
-    
-    it "should return the correct number of friends blocked" do
-      @david.blocked.count.should == 1
-      @david.blocked.should include(@john)
-    end
-    
-    it "should not return any blocked friends in friends or invited or pending invites" do
-      @john.friends.count.should == 1
-      @john.friends.should include(@james)
-      @john.friends.should_not include(@david)
-
-      @john.invited.count.should == 1
-      @john.invited.should_not include(@david)
-      @john.invited.should include(@james)
-      
-      @john.pending_invited.count.should == 1
-      @john.pending_invited.should_not include(@david)
-      @john.pending_invited.should include(@jane)
-      
-      @david.friends.count.should == 0
-    end
-    
-    it "should not return any blocked friends for the friend who was blocked" do
-      @john.blocked.count.should == 0
-    end    
+    it "should allow to block author of the invitation by invited user" do
+      @john.block(@jane).should be_true
+      @jane.block(@victoria).should be_true
+    end
+
+    it "should not allow to block invited user by invitation author" do
+      @jane.block(@john).should be_false
+      @victoria.block(@jane).should be_false
+    end
+
+    it "should allow to block approved users on both sides" do
+      @james.block(@jane).should be_true
+      @victoria.block(@james).should be_true
+    end
+
+    it "should not allow to block not connected user" do
+      @david.block(@peter).should be_false
+      @peter.block(@david).should be_false
+    end
+
+    it "should not allow to block already blocked user" do
+      @john.block(@jane).should be_true
+      @john.block(@jane).should be_false
+      @james.block(@jane).should be_true
+      @james.block(@jane).should be_false
+    end
+
+    it "should list the blocked users" do
+      @jane.blocked.should be_empty
+      @peter.blocked.should be_empty
+      @james.blocked.should == [@john]
+      @victoria.blocked.should == [@mary]
+      @david.blocked.should =~ [@john, @victoria]
+    end
+
+    it "should not list blocked users in friends" do
+      @james.friends.should =~ [@jane, @victoria]
+      @james.blocked.each do |user|
+        @james.friends.should_not include(user)
+        user.friends.should_not include(@james)
+    end
+    end
+
+    it "should not list blocked users in invited" do
+      @victoria.invited.should == [@james]
+      @victoria.blocked.each do |user|
+        @victoria.invited.should_not include(user)
+        user.invited_by.should_not include(@victoria)
+      end
+    end
+
+    it "should not list blocked users in invited pending by" do
+      @david.pending_invited_by.should be_empty
+      @david.blocked.each do |user|
+        @david.pending_invited_by.should_not include(user)
+        user.pending_invited.should_not include(@david)
+      end
+    end
+
+    it "should check if a user is blocked" do
+      @james.blocked?(@john).should be_true
+      @victoria.blocked?(@mary).should be_true
+      @david.blocked?(@john).should be_true
+      @david.blocked?(@victoria).should be_true
+    end
   end
 
   context "when unblocking friendships" do
-    before(:each) do
+    before do
       Friendship.delete_all
+      @john.invite(@james).should be_true
+      @james.approve(@john).should be_true
+      @john.block(@james).should be_true
+      @john.unblock(@james).should be_true
+      @mary.invite(@victoria).should be_true
+      @victoria.approve(@mary).should be_true
+      @victoria.block(@mary).should be_true
+      @victoria.unblock(@mary).should be_true
+      @victoria.invite(@david).should be_true
+      @david.block(@victoria).should be_true
+      @david.unblock(@victoria).should be_true
+      @john.invite(@david).should be_true
+      @david.block(@john).should be_true
+      @peter.invite(@elisabeth).should be_true
+      @elisabeth.block(@peter).should be_true
+      @jane.invite(@john).should be_true
+      @jane.invite(@james).should be_true
+      @james.approve(@jane).should be_true
+      @victoria.invite(@jane).should be_true
+      @victoria.invite(@james).should be_true
+      @james.approve(@victoria).should be_true
+    end
 
-      @john.invite(@jane).should == true
-      @john.invite(@david).should == true
-      @david.approve(@john).should == true
-      @david.block(@john).should == true
-      @david.unblock(@john).should == true
-      @john.unblock(@victoria).should == false
+    it "should allow to unblock prevoiusly blocked user" do
+      @david.unblock(@john).should be_true
+      @elisabeth.unblock(@peter).should be_true
     end
 
-    it "should allow to unblock only invited user" do
-      @jane.approve(@john).should == true
-      @jane.block(@john).should == true
-      @john.unblock(@jane).should == false
-      @jane.unblock(@john).should == true
+    it "should not allow to unblock not prevoiusly blocked user" do
+      @john.unblock(@jane).should be_false
+      @james.unblock(@jane).should be_false
+      @victoria.unblock(@jane).should be_false
+      @james.unblock(@victoria).should be_false
     end
 
-    it "should return the correct number of friends blocked" do
-      @john.blocked.count.should == 0
-      @david.blocked.count.should == 0
+    it "should not allow to unblock blocked user by himself" do
+      @john.unblock(@david).should be_false
+      @peter.unblock(@elisabeth).should be_false
     end
 
-    it "should return unblocked users in friends" do
-      @john.friends.count.should == 1
-      @john.friends.should include(@david)
-      @john.friends.should_not include(@victoria)
+    it "should list unblocked users in friends" do
+      @john.friends.should == [@james]
+      @mary.friends.should == [@victoria]
+      @victoria.friends.should =~ [@mary, @james]
+      @james.friends.should =~ [@john, @jane, @victoria]
+    end
+
+    it "should list unblocked users in invited" do
+      @john.invited.should == [@james]
+      @mary.invited.should == [@victoria]
+    end
+
+    it "should list unblocked users in invited by" do
+      @victoria.invited_by.should == [@mary]
+      @james.invited_by.should =~ [@john, @jane, @victoria]
+    end
+
+    it "should list unblocked users in pending invited" do
+      @victoria.pending_invited.should =~ [@jane, @david]
+    end
 
-      @john.invited.count.should == 1
-      @john.invited.should include(@david)
-      @john.invited.should_not include(@victoria)
-      
-      @john.pending_invited.count.should == 1
-      @john.pending_invited.should include(@jane)
-      @john.pending_invited.should_not include(@david)
-      @john.pending_invited.should_not include(@victoria)
+    it "should list unblocked users in pending invited by" do
+      @david.reload
+      @david.pending_invited_by.should == [@victoria]
     end
   end
 end

data/spec/friendship_model_spec.rb

@@ -1,26 +1,122 @@
 require 'spec_helper'
 
 describe Amistad::FriendshipModel do
-  
-  before(:each) do
-    Friendship.delete_all
+
+  before(:all) do
+    %w(Jane David).each do |name|
+      instance_variable_set("@#{name.downcase}".to_sym, User.create(:name => name))
+    end
   end
-  
-  it "validates presence of the user's id and the friend's id" do
+
+  it "should validate presence of the user's id and the friend's id" do
     friendship = Friendship.new
-    friendship.save.should == false
-    
-    friendship = Friendship.new(:user_id => 1, :friend_id => 2)
-    friendship.save.should == true
+    friendship.valid?.should be_false
+    friendship.errors.should include(:user_id)
+    friendship.errors.should include(:friend_id)
+    friendship.errors.size.should == 2
+  end
+
+  context "when creating friendship" do
+    before do
+      Friendship.delete_all
+      @jane.invite(@david)
+      @friendship = Friendship.first
+    end
+
+    it "should be pending" do
+      @friendship.pending?.should be_true
+    end
+
+    it "should not be approved" do
+      @friendship.approved?.should be_false
+    end
+
+    it "should be active" do
+      @friendship.active?.should be_true
+    end
+
+    it "should not be blocked" do
+      @friendship.blocked?.should be_false
+    end
+
+    it "should be available to block only by invited user" do
+      @friendship.can_block?(@david).should be_true
+      @friendship.can_block?(@sane).should be_false
+    end
+
+    it "should not be availabel to unblock" do
+      @friendship.can_unblock?(@jane).should be_false
+      @friendship.can_unblock?(@david).should be_false
+    end
   end
-  
-  it "is in pending state when created" do
-    friendship = Friendship.create(:user_id => 1, :friend_id => 2)
-    friendship.pending?.should == true
+
+  context "when approving friendship" do
+    before do
+      Friendship.delete_all
+      @jane.invite(@david)
+      @david.approve(@jane)
+      @friendship = Friendship.first
+    end
+
+    it "should be approved" do
+      @friendship.approved?.should be_true
+    end
+
+    it "should not be pending" do
+      @friendship.pending?.should be_false
+    end
+
+    it "should be active" do
+      @friendship.active?.should be_true
+    end
+
+    it "should not be blocked" do
+      @friendship.blocked?.should be_false
+    end
+
+    it "should be available to block by both users" do
+      @friendship.can_block?(@sane).should be_true
+      @friendship.can_block?(@david).should be_true
+    end
+
+    it "should not be availabel to unblock" do
+      @friendship.can_unblock?(@jane).should be_false
+      @friendship.can_unblock?(@david).should be_false
+    end
   end
-  
-  it "is not in a blocked state when created" do
-    friendship = Friendship.create(:user_id => 1, :friend_id => 2)
-    friendship.blocked?.should == false
+
+  context "when blocking friendship" do
+    before do
+      Friendship.delete_all
+      @jane.invite(@david)
+      @david.block(@jane)
+      @friendship = Friendship.first
+    end
+
+    it "should not be approved" do
+      @friendship.approved?.should be_false
+    end
+
+    it "should be pending" do
+      @friendship.pending?.should be_true
+    end
+
+    it "should not be active" do
+      @friendship.active?.should be_false
+    end
+
+    it "should be blocked" do
+      @friendship.blocked?.should be_true
+    end
+
+    it "should not be available to block" do
+      @friendship.can_block?(@sane).should be_false
+      @friendship.can_block?(@david).should be_false
+    end
+
+    it "should be available to unblock only by user who blocked it" do
+      @friendship.can_unblock?(@david).should be_true
+      @friendship.can_unblock?(@jane).should be_false
+    end
   end
 end

data/spec/spec_helper.rb

@@ -17,9 +17,11 @@ ActiveRecord::Schema.define do
   create_table :friendships, :force => true do |t|
     t.integer :user_id
     t.integer :friend_id
+    t.integer :blocker_id
     t.boolean :pending, :default => true
-    t.boolean :blocked, :default => false
   end
+
+  add_index :friendships, [:user_id, :friend_id], :unique => true
 end
 
 class User < ActiveRecord::Base

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 8
-  version: 0.5.8
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Rawane ZOSSOU
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-08 00:00:00 +01:00
+date: 2011-01-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,13 +23,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 1
         - 0
-        - 0
-        version: 1.0.0
+        - 7
+        version: 1.0.7
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,9 +42,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 2
-        - 2
+        - 4
         - 0
-        version: 2.2.0
+        version: 2.4.0
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -58,8 +58,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 3
+        version: 3.0.3
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -68,7 +68,7 @@ dependencies:
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
         segments: 
         - 1
@@ -88,7 +88,6 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- .rspec
 - CHANGELOG
 - Gemfile
 - LICENCE

data/.rspec

@@ -1,4 +0,0 @@
---colour
---format
-progress
-mtime