amistad 0.7.5 → 0.9.0

data/.gitignore

@@ -3,4 +3,7 @@ pkg/*
 .bundle
 spec/db/*.db
 nbproject
-.rvmrc
+.rvmrc
+*.sw[a-z]
+.rspec
+database.yml

data/Gemfile.lock

@@ -1,54 +1,66 @@
 PATH
   remote: .
   specs:
-    amistad (0.7.5)
+    amistad (0.9.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.1.0)
-      activesupport (= 3.1.0)
-      bcrypt-ruby (~> 3.0.0)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
       builder (~> 3.0.0)
-      i18n (~> 0.6)
-    activerecord (3.1.0)
-      activemodel (= 3.1.0)
-      activesupport (= 3.1.0)
-      arel (~> 2.2.1)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
       tzinfo (~> 0.3.29)
-    activesupport (3.1.0)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
       multi_json (~> 1.0)
-    arel (2.2.1)
-    bcrypt-ruby (3.0.1)
-    bson (1.4.0)
-    bson_ext (1.4.0)
-    builder (3.0.0)
+    arel (3.0.2)
+    awesome_print (1.1.0)
+    bson (1.7.0)
+    bson_ext (1.7.0)
+      bson (~> 1.7.0)
+    builder (3.0.4)
+    database_cleaner (0.9.1)
     diff-lcs (1.1.3)
-    fuubar (0.0.6)
+    fuubar (1.1.0)
       rspec (~> 2.0)
-      rspec-instafail (~> 0.1.8)
-      ruby-progressbar (~> 0.0.10)
-    i18n (0.6.0)
-    mongo (1.4.0)
-      bson (= 1.4.0)
-    mongoid (2.0.2)
+      rspec-instafail (~> 0.2.0)
+      ruby-progressbar (~> 1.0.0)
+    i18n (0.6.1)
+    mongo (1.7.0)
+      bson (~> 1.7.0)
+    mongo_mapper (0.12.0)
       activemodel (~> 3.0)
-      mongo (~> 1.3)
+      activesupport (~> 3.0)
+      plucky (~> 0.5.2)
+    mongoid (3.0.9)
+      activemodel (~> 3.1)
+      moped (~> 1.1)
+      origin (~> 1.0)
       tzinfo (~> 0.3.22)
-    multi_json (1.0.3)
-    rake (0.9.2)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-instafail (0.1.8)
-    rspec-mocks (2.6.0)
-    ruby-progressbar (0.0.10)
-    sqlite3 (1.3.4)
-    tzinfo (0.3.30)
+    moped (1.2.7)
+    multi_json (1.3.6)
+    mysql2 (0.3.11)
+    origin (1.0.9)
+    pg (0.14.1)
+    plucky (0.5.2)
+      mongo (~> 1.5)
+    rake (0.9.2.2)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-instafail (0.2.4)
+    rspec-mocks (2.11.3)
+    ruby-progressbar (1.0.2)
+    sqlite3 (1.3.6)
+    tzinfo (0.3.33)
 
 PLATFORMS
   ruby
@@ -56,10 +68,15 @@ PLATFORMS
 DEPENDENCIES
   activerecord
   amistad!
-  bson_ext (~> 1.3)
+  awesome_print
+  bson_ext
   bundler
+  database_cleaner
   fuubar
-  mongoid (~> 2.0.0)
+  mongo_mapper
+  mongoid
+  mysql2
+  pg
   rake
   rspec
   sqlite3

data/README.markdown

@@ -1,6 +1,6 @@
 # amistad #
 
-Amistad adds friendships management into a rails 3.0 application. it supports ActiveRecord 3.0.x and Mongoid 2.0.x.
+Amistad adds friendships management into a rails 3.0 application. it supports ActiveRecord 3.0.x, Mongoid 3.0.x and MongoMapper 0.12.0.
 
 ## Installation ##
 
@@ -14,141 +14,44 @@ Then run:
 
 ## Usage ##
 
-If you are using ActiveRecord, you need to generate a friendship model. Amistad has a generator for this task :
+Refer to the wiki pages for usage and friendships management.
 
-    rails generate amistad:install  
-    
-This command creates a new model called __friendship__ in *'app/models'* :
-
-    class Friendship < ActiveRecord::Base
-      include Amistad::FriendshipModel
-    end
-
-It also creates a new migration for the friendship model so don't forget to migrate your database :
-
-    rake db:migrate
-
-If you are using Mongoid, you don't need a friendship model. Finally, activate __amistad__ in your user model :
-
-    class User < ActiveRecord::Base  
-      include Amistad::FriendModel
-    end
-    
-or :
-
-    class User
-      include Mongoid::Document
-      include Amistad::FriendModel
-    end
-    
-## Friendships management ##
-
-### Creating friendships ###
-To create a new friendship with another user use the method called __invite()__ :
-
-    @john.invite @jane
-    @peter.invite @john
-    @peter.invite @jane
-    @victoria.invite @john
-    
-The __invite()__ method return *true* if the friendship successfully created, otherwise it returns *false*. The friendships remain in pending state until they are approved by the user requested. To approve the friendship created above use the method called __approve()__ :
-
-    @jane.approve @john
-    @john.approve @peter
-    @jane.approve @peter
-    
-As __invite()__, __approve()__ return *true* if the friendship was successfuly approved or *false* if not.
-
-### Listing friends ###
-
-There are two types of friends in __amistad__ :
-
-- the friends who were invited by the user
-- the friends who invited the user
-
-To get the friend who where invited by __@john__, use the __invited()__ method :
-
-    @john.invited #=> [@jane]
-    
-To get the friends who invited __@john__, use the __invited_by()__ method :
-
-    @john.invited_by #=> [@peter]
-    
-To get all the friends of __@john__ (those he invited and those who invited him) :
-
-    @john.friends #=> [@jane, @peter]
-    
-To get the pending friendships use :
-
-    @victoria.pending_invited #=> [@john]
-    @john.pending_invited_by #=> [@victoria]
-    
-It is also possible to check if two users are friends :
-
-    @john.friend_with? @jane #=> true
-    @victoria.friend_with? @john #=> false
-
-You can also check if a user is somehow connected to another :
-
-    @john.connected_with? @jane #=> true
-    @victoria.connected_with? @john #=> true
-
-You can also check if a user was invited by anoter :
-
-    @john.invited_by? @john #=> true
-    @victoria.invited_by? @john #=> false
-
-You can also check if a user invited another :
-
-    @john.invited? @jane #=> true
-
-You can also find the friends that two users have in common :
-
-    @john.common_friends_with(@peter) #=> [@jane]
-    
-### Removing friendships ###
-
-The __remove_friendship()__ method allow a user to remove its friendships :
-
-    @john.remove_friendship @jane
-    @john.remove_friendship @peter
-    @john.remove_friendship @victoria
-    
-### Blocking friendships ###
-
-The __block()__ method allow a user to block a friendship with another user :
-
-    @john.invite @jane
-    @jane.block @john
-    
-To get the blocked users :
-
-    @jane.blocked #=> [@john]
+## Testing ##
 
-You can also check if a user is blocked :
+There are rake tasks available which allow you to run the activerecord tests for three rdbms:
 
-    @jane.blocked? @john #=> true
+    rake spec:activerecord:sqlite
+    rake spec:activerecord:mysql
+    rake spec:activerecord:postgresql
 
-### Unblocking friendship ###
+In order to run these tasks you need to create a confiuration file for the databases connections:
 
-The __unblock()__ method allow a user to unblock previously blocked friendship with another user :
+    spec/support/activerecord/database.yml
 
-    @jane.block @john
-    @jane.blocked #=> [@john]
+    sqlite:
+      adapter: "sqlite3"
+      database: ":memory:"
 
-    @jane.unblock @john
-    @jane.blocked #=> []
+    mysql:
+      adapter: mysql2
+      encoding: utf8
+      database: <name of mysql database>
+      username: <username>
+      password: <password>
 
-## Testing ##
+    postgresql:
+      adapter: postgresql
+      encoding: unicode
+      database: <name of postgresql database>
+      username: <username>
+      password: <password>
 
-It is possible to test amistad by running one of the following commands from the gem directory:
+Of course there are some tasks for running mongodb orms based tests:
 
-    rspec spec/activerecord/ # activerecord tests
-    rspec spec/mongoid/      # mongoid tests
-    
-Remember that amistad is only compatible with ActiveRecord 3.0.x and Mongoid 2.0.x.
+    rake spec:mongoid
+    rake spec:mongo_mapper
 
-You can also run `rake` by itself and it will run the ActiveRecord tests followed by the Mongoid tests.
+The default rake tasks runs the ActiveRecord tests for the three rdbms followed by the Mongoid tests.
 
 ## Contributors ##
 
@@ -156,7 +59,7 @@ You can also run `rake` by itself and it will run the ActiveRecord tests followe
 * Adrian Dulić : unblock friendships (and many other improvements)
 
 ## Note on Patches/Pull Requests ##
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a future version unintentionally.

data/Rakefile

@@ -5,18 +5,52 @@ require 'rspec'
 require 'rspec/core/rake_task'
 
 namespace :spec do
+  desc "Run Rspec tests for ActiveRecord (with sqlite as RDBM)"
   RSpec::Core::RakeTask.new(:activerecord) do |t|
     t.pattern = "./spec/activerecord/**/*_spec.rb"
     t.rspec_opts = "--format Fuubar"
   end
 
+  desc "Run Rspec tests for Mongoid"
   RSpec::Core::RakeTask.new(:mongoid) do |t|
     t.pattern = "./spec/mongoid/**/*_spec.rb"
     t.rspec_opts = "--format Fuubar"
   end
+
+  desc "Run Rspec tests for MongoMapper"
+  RSpec::Core::RakeTask.new(:mongo_mapper) do |t|
+    t.pattern = "./spec/mongo_mapper/**/*_spec.rb"
+    t.rspec_opts = "--format Fuubar"
+  end
+
+  namespace :activerecord do
+    desc "run activerecord tests on a sqlite database"
+    task :sqlite do
+      ENV['RDBM'] = 'sqlite'
+      Rake::Task['spec:activerecord'].reenable
+      Rake::Task['spec:activerecord'].invoke
+    end
+    
+    desc "run activerecord tests on a mysql database"
+    task :mysql do
+      ENV['RDBM'] = 'mysql'
+      Rake::Task['spec:activerecord'].reenable
+      Rake::Task['spec:activerecord'].invoke
+    end
+
+    desc "run activerecord tests on a postgresql database"
+    task :postgresql do
+      ENV['RDBM'] = 'postgresql'
+      Rake::Task['spec:activerecord'].reenable
+      Rake::Task['spec:activerecord'].invoke
+    end
+  end
 end
 
 task :default do
-  Rake::Task['spec:activerecord'].invoke
+  Rake::Task['spec:activerecord:sqlite'].invoke
+  Rake::Task['spec:activerecord:mysql'].invoke
+  Rake::Task['spec:activerecord:postgresql'].invoke
   Rake::Task['spec:mongoid'].invoke
+  Rake::Task['spec:mongo_mapper'].invoke
 end

data/amistad.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Rawane ZOSSOU"]
   s.email       = ["dev@raw1z.fr"]
-  s.homepage    = "http://github.com/raw1z/amistad"
+  s.homepage    = "https://github.com/raw1z/amistad/wiki"
   s.summary     = %q{Adds friendships management into a rails 3.0 application}
   s.description = %q{Extends your user model with friendships management methods}
 
@@ -18,10 +18,15 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "activerecord"
+  s.add_development_dependency "mysql2"
+  s.add_development_dependency "pg"
+  s.add_development_dependency "database_cleaner"
   s.add_development_dependency "sqlite3"
-  s.add_development_dependency "mongoid", "~> 2.0.0"
-  s.add_development_dependency "bson_ext", "~> 1.3"
+  s.add_development_dependency "mongoid"
+  s.add_development_dependency "bson_ext"
   s.add_development_dependency "fuubar"
+  s.add_development_dependency "awesome_print"
+  s.add_development_dependency "mongo_mapper"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/amistad.rb

@@ -1,11 +1,16 @@
-if defined?(ActiveRecord)
-  require 'amistad/active_record/friend_model'
-  require 'amistad/active_record/friendship_model'
-end
+require 'active_support/concern'
+require 'active_support/dependencies/autoload'
+require 'amistad/config'
 
-if defined?(Mongoid)
-  require 'amistad/mongoid/friend_model'
-end
+module Amistad
+  extend ActiveSupport::Autoload
 
-require 'amistad/friend_model'
-require 'amistad/friendship_model'
+  autoload :ActiveRecordFriendModel
+  autoload :ActiveRecordFriendshipModel
+  autoload :MongoFriendModel
+  autoload :MongoidFriendModel
+  autoload :MongoMapperFriendModel
+  autoload :FriendshipModel
+  autoload :FriendModel
+  autoload :Friendships
+end

data/lib/amistad/active_record_friend_model.rb

@@ -0,0 +1,157 @@
+module Amistad
+  module ActiveRecordFriendModel
+    extend ActiveSupport::Concern
+
+    included do
+      #####################################################################################
+      # friendships
+      #####################################################################################
+      has_many  :friendships,
+        :class_name => "Amistad::Friendships::#{Amistad.friendship_model}",
+        :foreign_key => "friendable_id"
+
+      has_many  :pending_invited,
+        :through => :friendships,
+        :source => :friend,
+        :conditions => { :'friendships.pending' => true, :'friendships.blocker_id' => nil }
+
+      has_many  :invited,
+        :through => :friendships,
+        :source => :friend,
+        :conditions => { :'friendships.pending' => false, :'friendships.blocker_id' => nil }
+
+      #####################################################################################
+      # inverse friendships
+      #####################################################################################
+      has_many  :inverse_friendships,
+        :class_name => "Amistad::Friendships::#{Amistad.friendship_model}",
+        :foreign_key => "friend_id"
+
+      has_many  :pending_invited_by,
+        :through => :inverse_friendships,
+        :source => :friendable,
+        :conditions => { :'friendships.pending' => true, :'friendships.blocker_id' => nil }
+
+      has_many  :invited_by,
+        :through => :inverse_friendships,
+        :source => :friendable,
+        :conditions => { :'friendships.pending' => false, :'friendships.blocker_id' => nil }
+
+      #####################################################################################
+      # blocked friendships
+      #####################################################################################
+      has_many  :blocked_friendships,
+        :class_name => "Amistad::Friendships::#{Amistad.friendship_model}",
+        :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 => :friendable,
+        :conditions => "friendable_id <> blocker_id"
+    end
+
+    # suggest a user to become a friend. If the operation succeeds, the method returns true, else false
+    def invite(user)
+      return false if user == self || find_any_friendship_with(user)
+      Amistad.friendship_class.new{ |f| f.friendable = self ; f.friend = user }.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? || invited?(user)
+      friendship.update_attribute(:pending, false)
+    end
+
+    # deletes a friendship
+    def remove_friendship(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.reload
+      self.invited + self.invited_by
+    end
+
+    # total # of invited and invited_by without association loading
+    def total_friends
+      self.invited(false).count + self.invited_by(false).count
+    end
+
+    # blocks a friendship
+    def block(user)
+      friendship = find_any_friendship_with(user)
+      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.can_unblock?(self)
+      friendship.update_attribute(:blocker, nil)
+    end
+
+    # returns the list of blocked friends
+    def blocked
+      self.reload
+      self.blockades + self.blockades_by
+    end
+
+    # total # of blockades and blockedes_by without association loading
+    def total_blocked
+      self.blockades(false).count + self.blockades_by(false).count
+    end
+
+    # checks if a user is blocked
+    def blocked?(user)
+      blocked.include?(user)
+    end
+
+    # checks if a user is a friend
+    def friend_with?(user)
+      friends.include?(user)
+    end
+
+    # checks if a current user is connected to given user
+    def connected_with?(user)
+      find_any_friendship_with(user).present?
+    end
+
+    # 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.friendable_id == user.id
+    end
+
+    # checks if a current user invited given user
+    def invited?(user)
+      friendship = find_any_friendship_with(user)
+      return false if friendship.nil?
+      friendship.friend_id == user.id
+    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 = Amistad.friendship_class.where(:friendable_id => self.id, :friend_id => user.id).first
+      if friendship.nil?
+        friendship = Amistad.friendship_class.where(:friendable_id => user.id, :friend_id => self.id).first
+      end
+      friendship
+    end
+  end
+end