has_many_friends 0.0.1

data/README

@@ -0,0 +1,73 @@
+HasManyFriends - Steve Ehrenberg - http://dnite.org
+===================================================
+has_many_friends is a plugin based off of the friendship_plugin that can be found
+here (http://svn.webwideconsulting.com/svn/friendship_plugin/). This version of the
+plugin adds some features I wanted as well as eliminates the need for 2 friendship
+rows created in the table. The goal is to make it relatively seamless for anyone to
+create a fully functional friends system for their application.
+
+
+Setup
+=====
+To use this plugin, you will first need to install it. This can be done quite simply
+with the following command.
+
+   script/plugin install http://svn.dnite.org/has_many_friends
+
+We'll need to generate the model and migration for your friendship table.
+
+   script/generate hmf_friendship_model Friendship
+   rake db:migrate
+   
+If you will be running tests, you may need to prepare your test database again.
+
+   rake db:test:prepare
+
+You should be just about set! All you need to do is add the following method
+to your User model.
+
+   class User < ActiveRecord::Base
+     has_many_friends
+     # the rest of your user model ...
+     # ...
+   end
+
+
+Usage
+=====
+After the plugin is installed. All of these super cool methods will be attached to 
+any user.
+
+These methods are the actual associations. They return what you'd expect.
+   user.friends_for_me
+   user.friends_by_me
+   user.pending_friends_for_me
+   user.pending_friends_by_me
+
+Again, these will return what you would expect them to return.
+   user.friends
+   user.pending_friends
+   user.pending_or_accepted_friends
+
+## The following 3 methods were changed as of revision 8. They have been listed here
+## as these methods, but for some reason, i never changed their names in the actual
+## plugin file. If your using a pre-8 version and things broke for you, use the new
+## method names in your application. Sorry for the inconvenience.
+Returns true if user is friends with friend.
+   user.is_friends_with? friend
+   user.is_pending_friends_with? friend
+   user.is_friends_or_pending_with? friend
+
+Creates, deletes or updates friendship requests.
+   user.request_friendship_with friend
+   user.delete_friendship_with friend
+   user.accept_friendship_with friend
+
+Bypass the request and just make a friend.
+   user.become_friends_with! friend
+
+Returns the friendship object (good for looking up extra attributes about
+the friendship, like when it was accepted and such.
+   user.friendship friend
+
+Copyright (c) 2007 Steve Ehrenberg, released under the MIT license

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the has_many_friends plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the has_many_friends plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HasManyFriends'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/has_many_friends.rb

@@ -0,0 +1,135 @@
+module HasManyFriends
+
+  module UserExtensions
+  
+    def self.included( recipient )
+      recipient.extend( ClassMethods )
+    end
+    
+    module ClassMethods
+      def has_many_friends(options={})
+        has_many :friendships_by_me,
+                 :foreign_key => 'user_id',
+                 :class_name => 'Friendship'
+        
+        has_many :friendships_for_me,
+                 :foreign_key => 'friend_id',
+                 :class_name => 'Friendship'
+        
+        has_many :friends_by_me,
+                 :through => :friendships_by_me,
+                 :source => :friendshipped_for_me,
+                 :conditions => 'accepted_at IS NOT NULL' do
+                  def online
+                    find(:all, :conditions => ['status <> ? AND updated_at > ?', 'offline', 65.seconds.ago]) if options[:online_method]
+                  end
+                 end
+        
+        has_many :friends_for_me,
+                 :through => :friendships_for_me,
+                 :source => :friendshipped_by_me,
+                 :conditions => 'accepted_at IS NOT NULL' do
+                  def online
+                    find(:all, :conditions => ['status <> ? AND updated_at > ?', 'offline', 65.seconds.ago]) if options[:online_method]
+                  end
+                 end
+        
+        has_many :pending_friends_by_me,
+                 :through => :friendships_by_me,
+                 :source => :friendshipped_for_me,
+                 :conditions => 'accepted_at IS NULL'
+        
+        has_many :pending_friends_for_me,
+                 :through => :friendships_for_me,
+                 :source => :friendshipped_by_me,
+                 :conditions => 'accepted_at IS NULL'
+        
+        include HasManyFriends::UserExtensions::InstanceMethods
+      end
+    end
+    
+    module InstanceMethods
+      
+      # Returns a list of all of a users accepted friends.
+      def friends
+        self.friends_for_me + self.friends_by_me
+      end
+      
+      # Return a list of all friends who are currently online.
+      # This won't return anything unless you passed the :online_method
+      # option to has_many_friends.
+      def online_friends
+        self.friends_by_me.online + self.friends_for_me.online
+      end
+      
+      # Returns a list of all pending friendships.
+      def pending_friends
+        self.pending_friends_by_me + self.pending_friends_for_me
+      end
+      
+      # Returns a full list of all pending and accepted friends.
+      def pending_or_accepted_friends
+        self.friends + self.pending_friends
+      end
+      
+      # Accepts a user object and returns the friendship object 
+      # associated with both users.
+      def friendship(friend)
+        Friendship.find(:first, :conditions => ['(user_id = ? AND friend_id = ?) OR (friend_id = ? AND user_id = ?)', self.id, friend.id, self.id, friend.id])
+      end
+      
+      # Accepts a user object and returns true if both users are
+      # friends and the friendship has been accepted.
+      def is_friends_with?(friend)
+        self.friends.include?(friend)
+      end
+      
+      # Accepts a user object and returns true if both users are
+      # friends but the friendship hasn't been accepted yet.
+      def is_pending_friends_with?(friend)
+        self.pending_friends.include?(friend)
+      end
+      
+      # Accepts a user object and returns true if both users are
+      # friends regardless of acceptance.
+      def is_friends_or_pending_with?(friend)
+        self.pending_or_accepted_friends.include?(friend)
+      end
+      
+      # Accepts a user object and creates a friendship request
+      # between both users.
+      def request_friendship_with(friend)
+        Friendship.create!(:friendshipped_by_me => self, 
+                           :friendshipped_for_me => friend) unless self.is_friends_or_pending_with?(friend) || self == friend
+      end
+      
+      # Accepts a user object and updates an existing friendship to
+      # be accepted.
+      def accept_friendship_with(friend)
+        self.friendship(friend).update_attribute(:accepted_at, Time.now)
+      end
+      
+      # Accepts a user object and deletes a friendship between both 
+      # users.
+      def delete_friendship_with(friend)
+        self.friendship(friend).destroy if self.is_friends_or_pending_with?(friend)
+      end
+      
+      # Accepts a user object and creates a friendship between both 
+      # users. This method bypasses the request stage and makes both
+      # users friends without needing to be accepted.
+      def become_friends_with(friend)
+        unless self.is_friends_with?(friend)
+          unless self.is_pending_friends_with?(friend)
+            Friendship.create!(:friendshipped_by_me => self, :friendshipped_for_me => friend, :accepted_at => Time.now)
+          else
+            self.friendship(friend).update_attribute(:accepted_at, Time.now)
+          end
+        else
+          self.friendship(friend)
+        end
+      end
+      
+    end  
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send( :include, HasManyFriends::UserExtensions )

data/test/has_many_friends_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class HasManyFriendsTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: has_many_friends
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Haberer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Simple Models for managing simple friendship relationships.
+email: bhaberer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/has_many_friends.rb
+- rails/init.rb
+- test/has_many_friends_test.rb
+- README
+has_rdoc: true
+homepage: http://weirdo513.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: has_many_friends
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Friendships.
+test_files: []
+