amistad 0.7.5 → 0.9.0

data/lib/amistad/active_record_friendship_model.rb

@@ -0,0 +1,52 @@
+module Amistad
+  module ActiveRecordFriendshipModel
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :friendable,
+        :class_name => Amistad.friend_model,
+        :foreign_key => "friendable_id"
+
+      belongs_to :friend,
+        :class_name => Amistad.friend_model,
+        :foreign_key => "friend_id"
+
+      belongs_to :blocker,
+        :class_name => Amistad.friend_model,
+        :foreign_key => "blocker_id"
+
+      validates_presence_of :friendable_id, :friend_id
+      validates_uniqueness_of :friend_id, :scope => :friendable_id
+    end
+
+    # 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.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 friendable
+    def can_block?(friendable)
+      active? && (approved? || (pending? && self.friend_id == friendable.id && friendable.class.to_s == Amistad.friend_model))
+    end
+
+    # returns true if a friendship can be unblocked by given friendable
+    def can_unblock?(friendable)
+      blocked? && self.blocker_id == friendable.id && friendable.class.to_s == Amistad.friend_model
+    end
+  end
+end

data/lib/amistad/config.rb

@@ -0,0 +1,21 @@
+module Amistad
+  class << self
+    attr_accessor :friend_model
+
+    def configure
+      yield self
+    end
+
+    def friend_model
+      @friend_model || 'User'
+    end
+
+    def friendship_model
+      "#{self.friend_model}Friendship"
+    end
+
+    def friendship_class
+      Amistad::Friendships.const_get(self.friendship_model)
+    end
+  end
+end

data/lib/amistad/friend_model.rb

@@ -3,15 +3,21 @@ module Amistad
     def self.included(receiver)
       if receiver.ancestors.map(&:to_s).include?("ActiveRecord::Base")
         receiver.class_exec do
-          include Amistad::ActiveRecord::FriendModel
+          include Amistad::ActiveRecordFriendModel
         end
       elsif receiver.ancestors.map(&:to_s).include?("Mongoid::Document")
         receiver.class_exec do
-          include Amistad::Mongoid::FriendModel
+          include Amistad::MongoidFriendModel
+          include Amistad::MongoFriendModel
+        end
+      elsif receiver.ancestors.map(&:to_s).include?("MongoMapper::Document")
+        receiver.class_exec do
+          include Amistad::MongoMapperFriendModel
+          include Amistad::MongoFriendModel
         end
       else
-        raise "Amistad only supports ActiveRecord and Mongoid"
+        raise "Amistad only supports ActiveRecord, Mongoid and MongoMapper"
       end
     end
   end
-end
+end

data/lib/amistad/friendship_model.rb

@@ -3,11 +3,11 @@ module Amistad
     def self.included(receiver)
       if receiver.ancestors.map(&:to_s).include?("ActiveRecord::Base")
         receiver.class_exec do
-          include Amistad::ActiveRecord::FriendshipModel
+          include Amistad::ActiveRecordFriendshipModel
         end
       else
         raise "Amistad only supports ActiveRecord and Mongoid"
       end
     end
   end
-end
+end

data/lib/amistad/friendships.rb

@@ -0,0 +1,19 @@
+module Amistad
+  module Friendships
+    if Object.const_defined? :ActiveRecord
+      const_set Amistad.friendship_model, Class.new(ActiveRecord::Base)
+      const_get(Amistad.friendship_model.to_sym).class_exec do
+        include Amistad::FriendshipModel
+        self.table_name = 'friendships'
+      end
+    elsif Object.const_defined? :Mongoid
+      Friendship = Class.new
+      Friendship.class_exec do
+        include Mongoid::Document
+        include Amistad::FriendshipModel
+      end
+    else
+      raise "Amistad only supports ActiveRecord and Mongoid"
+    end
+  end
+end

data/lib/amistad/mongo_friend_model.rb

@@ -0,0 +1,168 @@
+module Amistad
+  module MongoFriendModel
+    # suggest a user to become a friend. If the operation succeeds, the method returns true, else false
+    def invite(user)
+      return false if friendshiped_with?(user) or user == self or blocked?(user)
+      pending_friend_ids << user.id
+      user.pending_inverse_friend_ids << self.id
+      self.save && user.save
+    end
+
+    # approve a friendship invitation. If the operation succeeds, the method returns true, else false
+    def approve(user)
+      return false unless pending_inverse_friend_ids.include?(user.id) && user.pending_friend_ids.include?(self.id)
+      pending_inverse_friend_ids.delete(user.id)
+      user.pending_friend_ids.delete(self.id)
+      inverse_friend_ids << user.id
+      user.friend_ids << self.id
+      self.save && user.save
+    end
+
+    # returns the list of approved friends
+    def friends
+      self.invited + self.invited_by
+    end
+
+    # total # of invited and invited_by without association loading
+    def total_friends
+      (friend_ids + inverse_friend_ids).count
+    end
+
+    # return the list of invited friends
+    def invited
+      self.class.find(friend_ids)
+    end
+
+    # return the list of friends who invited
+    def invited_by
+      self.class.find(inverse_friend_ids)
+    end
+
+    # return the list of pending invited friends
+    def pending_invited
+      self.class.find(pending_friend_ids)
+    end
+
+    # return the list of pending friends who invited
+    def pending_invited_by
+      self.class.find(pending_inverse_friend_ids)
+    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
+
+    # checks if a user is a friend
+    def friend_with?(user)
+      return false if user == self
+      (friend_ids + inverse_friend_ids).include?(user.id)
+    end
+
+    # checks if a current user is connected to given user
+    def connected_with?(user)
+      friendshiped_with?(user)
+    end
+
+    # checks if a current user received invitation from given user
+    def invited_by?(user)
+      user.friend_ids.include?(self.id) or user.pending_friend_ids.include?(self.id)
+    end
+
+    # checks if a current user invited given user
+    def invited?(user)
+      self.friend_ids.include?(user.id) or self.pending_friend_ids.include?(user.id)
+    end
+
+    # deletes a friendship
+    def remove_friendship(user)
+      friend_ids.delete(user.id)
+      user.inverse_friend_ids.delete(self.id)
+      inverse_friend_ids.delete(user.id)
+      user.friend_ids.delete(self.id)
+      pending_friend_ids.delete(user.id)
+      user.pending_inverse_friend_ids.delete(self.id)
+      pending_inverse_friend_ids.delete(user.id)
+      user.pending_friend_ids.delete(self.id)
+      self.save && user.save
+    end
+
+    # blocks a friendship
+    def block(user)
+      if inverse_friend_ids.include?(user.id)
+        inverse_friend_ids.delete(user.id)
+        user.friend_ids.delete(self.id)
+        blocked_inverse_friend_ids << user.id
+      elsif pending_inverse_friend_ids.include?(user.id)
+        pending_inverse_friend_ids.delete(user.id)
+        user.pending_friend_ids.delete(self.id)
+        blocked_pending_inverse_friend_ids << user.id
+      elsif friend_ids.include?(user.id)
+        friend_ids.delete(user.id)
+        user.inverse_friend_ids.delete(user.id)
+        blocked_friend_ids << user.id
+      else
+        return false
+      end
+
+      self.save
+    end
+
+    # unblocks a friendship
+    def unblock(user)
+      if blocked_inverse_friend_ids.include?(user.id)
+        blocked_inverse_friend_ids.delete(user.id)
+        user.blocked_friend_ids.delete(self.id)
+        inverse_friend_ids << user.id
+        user.friend_ids << self.id
+      elsif blocked_pending_inverse_friend_ids.include?(user.id)
+        blocked_pending_inverse_friend_ids.delete(user.id)
+        pending_inverse_friend_ids << user.id
+        user.pending_friend_ids << self.id
+      elsif blocked_friend_ids.include?(user.id)
+        blocked_friend_ids.delete(user.id)
+        user.blocked_inverse_friend_ids.delete(self.id)
+        friend_ids << user.id
+        user.inverse_friend_ids << self.id
+      else
+        return false
+      end
+
+      self.save && user.save
+    end
+
+    # returns the list of blocked friends
+    def blocked
+      blocked_ids = blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids
+      self.class.find(blocked_ids)
+    end
+
+    # total # of blockades and blockedes_by without association loading
+    def total_blocked
+      (blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids).count
+    end
+
+    # checks if a user is blocked
+    def blocked?(user)
+      (blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids).include?(user.id) or user.blocked_pending_inverse_friend_ids.include?(self.id)
+    end
+
+    # check if any friendship exists with another user
+    def friendshiped_with?(user)
+      (friend_ids + inverse_friend_ids + pending_friend_ids + pending_inverse_friend_ids + blocked_friend_ids).include?(user.id)
+    end
+
+    # deletes all the friendships
+    def delete_all_friendships
+      friend_ids.clear
+      inverse_friend_ids.clear
+      pending_friend_ids.clear
+      pending_inverse_friend_ids.clear
+      blocked_friend_ids.clear
+      blocked_inverse_friend_ids.clear
+      blocked_pending_friend_ids.clear
+      blocked_pending_inverse_friend_ids.clear
+      self.save
+    end
+  end
+end

data/lib/amistad/mongo_mapper_friend_model.rb

@@ -0,0 +1,58 @@
+module Amistad
+  module MongoMapperFriendModel
+    extend ActiveSupport::Concern
+
+    included do
+      key :friend_ids,
+        Array,
+        :default => []
+
+      key :inverse_friend_ids,
+        Array,
+        :default => []
+
+      key :pending_friend_ids,
+        Array,
+        :default => []
+
+      key :pending_inverse_friend_ids,
+        Array,
+        :default => []
+
+      key :blocked_friend_ids,
+        Array,
+        :default => []
+
+      key :blocked_inverse_friend_ids,
+        Array,
+        :default => []
+
+      key :blocked_pending_friend_ids,
+        Array,
+        :default => []
+
+      key :blocked_pending_inverse_friend_ids,
+        Array,
+        :default => []
+
+      attr_accessible(
+        :friend_ids,
+        :inverse_friend_ids,
+        :pending_friend_ids,
+        :pending_inverse_friend_ids,
+        :blocked_friend_ids,
+        :blocked_inverse_friend_ids,
+        :blocked_pending_friend_ids,
+        :blocked_pending_inverse_friend_ids,
+      )
+
+      %w(friend_ids inverse_friend_ids pending_friend_ids pending_inverse_friend_ids blocked_friend_ids blocked_inverse_friend_ids blocked_pending_friend_ids blocked_pending_inverse_friend_ids).each do |attribute|
+        define_method(attribute.to_sym) do
+          value = read_attribute(attribute)
+          write_attribute(attribute, value = []) if value.nil?
+          value
+        end
+      end
+    end
+  end
+end

data/lib/amistad/mongoid_friend_model.rb

@@ -0,0 +1,58 @@
+module Amistad
+  module MongoidFriendModel
+    extend ActiveSupport::Concern
+
+    included do
+      field :friend_ids,
+        :type => Array,
+        :default => []
+
+      field :inverse_friend_ids,
+        :type => Array,
+        :default => []
+
+      field :pending_friend_ids,
+        :type => Array,
+        :default => []
+
+      field :pending_inverse_friend_ids,
+        :type => Array,
+        :default => []
+
+      field :blocked_friend_ids,
+        :type => Array,
+        :default => []
+
+      field :blocked_inverse_friend_ids,
+        :type => Array,
+        :default => []
+
+      field :blocked_pending_friend_ids,
+        :type => Array,
+        :default => []
+
+      field :blocked_pending_inverse_friend_ids,
+        :type => Array,
+        :default => []
+
+      attr_accessible(
+        :friend_ids,
+        :inverse_friend_ids,
+        :pending_friend_ids,
+        :pending_inverse_friend_ids,
+        :blocked_friend_ids,
+        :blocked_inverse_friend_ids,
+        :blocked_pending_friend_ids,
+        :blocked_pending_inverse_friend_ids,
+      )
+
+      %w(friend_ids inverse_friend_ids pending_friend_ids pending_inverse_friend_ids blocked_friend_ids blocked_inverse_friend_ids blocked_pending_friend_ids blocked_pending_inverse_friend_ids).each do |attribute|
+        define_method(attribute.to_sym) do
+          value = read_attribute(attribute)
+          write_attribute(attribute, value = []) if value.nil?
+          value
+        end
+      end
+    end
+  end
+end

data/lib/amistad/version.rb

@@ -1,3 +1,3 @@
 module Amistad
-  VERSION = "0.7.5"
+  VERSION = "0.9.0"
 end

data/lib/generators/amistad/install/install_generator.rb

@@ -16,7 +16,6 @@ module Amistad
 
       desc "This generator creates a friendship model and its migration file"
       def create_friendship_model_files
-        template 'friendship.rb', 'app/models/friendship.rb'
         template 'create_friendships.rb', "db/migrate/#{self.class.next_migration_number}_create_friendships.rb"
       end
     end

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

@@ -1,13 +1,13 @@
 class CreateFriendships < ActiveRecord::Migration
   def self.up
     create_table :friendships do |t|
-      t.integer :user_id
+      t.integer :friendable_id
       t.integer :friend_id
       t.integer :blocker_id
       t.boolean :pending, :default => true
     end
 
-    add_index :friendships, [:user_id, :friend_id], :unique => true
+    add_index :friendships, [:friendable_id, :friend_id], :unique => true
   end
 
   def self.down