aitor-tog_social 0.1

data/app/models/friendship.rb

@@ -0,0 +1,112 @@
+# Friendship objects represents the relation between two different members of the social network. The cardinality of the relationship is based on "inviter" and "invited" fields
+# that store who started the relationship and who is the _passive_ subject of the relationship.
+# 
+#  If you have two profiles, tom and jerry, the following combinations can take place:
+#
+#  inviter  invited  status
+#  -------  -------  -------
+#  tom      jerry    pending   tom is a follower of jerry OR jerry is followed by tom OR jerry is a 'following' of tom  
+#  jerry    tom      pending   jerry is a follower of tom OR tom is followed by jerry OR tom is a 'following' of jerry
+# 
+#  jerry    tom      accept  |                               | jerry "begun" the friendship
+#  or                        |  jerry and tom are friends    |    
+#  jerry    tom      accept  |                               | tom "begun" the friendship
+class Friendship  < ActiveRecord::Base
+   belongs_to :inviter, :class_name => 'Profile'
+   belongs_to :invited, :class_name => 'Profile'
+   
+   PENDING  = 0
+   ACCEPTED = 1
+   
+   def validate
+     errors.add('inviter', 'inviter and invited can not be the same user') if invited == inviter
+   end
+   class << self
+      
+      # Create a new follower of the +inviter+ user. Returns boolean value indicating if the relationship
+      # correctly created.
+      #
+      # ==== Options
+      #
+      # +inviter+  +Profile+ if the person that wants to be a follower if +invited+
+      # 
+      # +invited+  +Profile+ of the user followed by +inviter+
+      #
+      def add_follower(inviter, invited)
+        a = Friendship.create(:inviter => inviter, :invited => invited, :status => PENDING)
+        !a.new_record?
+      end
+          
+      # Create a friendship between the user and the target. Returns boolean value indicating if
+      # the relationship was correctly created.
+      #
+      # ==== Options
+      #
+      # +user+    +Profile+ or +User+ that purpose the friendship 
+      #
+      # +target+  +Profile+ or +User+ that receives the purposement relationship 
+      #
+      def make_friends(user, target)
+        transaction do
+          user = profile_of(user)
+          target = profile_of(target)
+          begin
+            find_friendship(user, target, PENDING).update_attribute(:status, ACCEPTED)
+            Friendship.create!(:inviter_id => target.id, :invited_id => user.id, :status => ACCEPTED)
+          rescue Exception
+            return make_friends(target, user) if user.followed_by? target
+            return add_follower(user, target)
+          end
+        end
+        true
+      end
+
+      def stop_being_friends(user, target)
+      transaction do
+        begin
+          find_friendship(target, user, ACCEPTED).update_attribute(:status, PENDING)
+          find_friendship(user, target, ACCEPTED).destroy
+          rescue Exception
+            return false
+          end
+        end
+        true
+      end
+
+      def reset(user, target)
+        begin
+          find_friendship(user, target).destroy
+          find_friendship(target, user, ACCEPTED).update_attribute(:status, PENDING)
+        rescue Exception
+          return true
+        end
+        true
+      end
+      
+      private
+      
+      def find_friendship(inviter, invited, status)
+         conditions = {:inviter_id => inviter.id, :invited_id => invited.id}
+         conditions.merge!(:status => status) if status
+         Friendship.find(:first, :conditions => conditions)
+      end
+      
+   end     
+
+   def accept!
+    self.update_attribute(:status, ACCEPTED)
+   end
+
+   private
+   def profile_of(user)
+     profile = case user
+     when User
+       user.profile
+     when Profile
+       user
+     else
+       nil
+     end
+   end
+   
+end

data/app/models/group.rb

@@ -0,0 +1,97 @@
+class Group < ActiveRecord::Base
+
+  belongs_to :author, :class_name => 'User', :foreign_key => 'user_id'
+
+  has_many :memberships
+
+  has_many :moderator_memberships, :class_name => 'Membership',
+                                   :conditions => ['memberships.moderator = ?', true]
+
+  has_many :members,    :through => :memberships, :source => :user,
+                        :conditions => ['memberships.state = ?', 'active']
+
+  has_many :pending_members,  :through => :memberships, :source => :user,
+                              :conditions => ['memberships.state = ?', 'pending']
+
+  has_many :moderators, :through => :moderator_memberships, :source => :user,
+                        :conditions => ['memberships.state = ?', 'active']
+
+
+  #file_column :image, :root_path => File.join(RAILS_ROOT, "public/system/group_photos"), :web_root => 'system/group_photos/', :magick => {
+  #    :versions => {
+  #      :big    => {:crop => "1:1", :size => Tog::Config["system.group.image.versions.big"],    :name => "big"},
+  #      :medium => {:crop => "1:1", :size => Tog::Config["system.group.image.versions.medium"], :name => "medium"},
+  #      :small  => {:crop => "1:1", :size => Tog::Config["system.group.image.versions.small"],  :name => "small" },
+  #      :tiny   => {:crop => "1:1", :size => Tog::Config["system.group.image.versions.tiny"],   :name => "tiny"  }
+  #    }
+  #}
+
+  acts_as_state_machine :initial => :pending
+  state :pending, :enter => :make_activation_code
+  state :active,  :enter => :do_activate
+  event :activate do
+    transitions :from => :pending, :to => :active
+  end
+
+  validates_uniqueness_of :name
+  validates_presence_of :name
+  validates_presence_of :author
+
+  def membership_of(user)
+    mem = memberships.select{|m| m.user == user}
+    return mem.first unless mem.blank?
+  end
+
+  def activate_membership(user)
+    mem = membership_of(user)
+    mem.activate! if mem && mem.pending?
+  end
+
+  def grant_moderator(user)
+    moderator_privileges(user,true)
+  end
+
+  def revoke_moderator(user)
+    moderator_privileges(user,false)
+  end
+
+  def moderator_privileges(user, grant=false)
+    mem = membership_of(user)
+    mem.moderator = grant
+    mem.save!
+  end
+
+  def join(user,moderator=false)
+    # todo Confirm what to do if th user is already a member. By now just ignore it and continue.
+    mem = membership_of(user)
+    mem = self.memberships.build(:user => user) unless mem
+    mem.save!
+    mem.activate! unless self.moderated?
+  end
+
+  def leave(user)
+    mem = membership_of(user)
+    mem.destroy if mem
+  end
+
+  def is_banned(user)
+    raise "Implement this..."
+  end
+
+  def ban(user)
+    raise "Implement this..."
+  end
+
+
+  protected
+  def make_activation_code
+    self.activation_code = Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
+  end
+
+  def do_activate
+    self.activated_at = Time.now.utc
+    self.activation_code = nil
+    self.moderator_memberships.each{|mod| mod.activate!}
+  end
+
+end

data/app/models/membership.rb

@@ -0,0 +1,25 @@
+class Membership < ActiveRecord::Base
+  belongs_to :group
+  belongs_to :user
+
+  acts_as_state_machine :initial => :pending
+  
+  state :pending, :enter => :make_activation_code
+  state :active, :enter => :do_activate
+  
+  event :activate do
+    transitions :from => :pending, :to => :active
+  end
+  
+  protected  
+  
+  def make_activation_code
+    self.activation_code = Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
+  end  
+  
+  def do_activate
+    self.activated_at = Time.now.utc
+    self.activation_code = nil
+  end
+  
+end

data/app/models/profile.rb

@@ -0,0 +1,117 @@
+class Profile < ActiveRecord::Base
+  belongs_to :user
+  
+  #file_column :icon, :root_path => File.join(RAILS_ROOT, "public/system/profile"), :web_root => 'system/profile/', :magick => {
+  #  :versions => { 
+  #    :big    => {:crop => "1:1", :size => Tog::Config["system.profile.image.versions.big"],    :name => "big"},
+  #    :medium => {:crop => "1:1", :size => Tog::Config["system.profile.image.versions.medium"], :name => "medium"},
+  #    :small  => {:crop => "1:1", :size => Tog::Config["system.profile.image.versions.small"],  :name => "small"},
+  #    :tiny   => {:crop => "1:1", :size => Tog::Config["system.profile.image.versions.tiny"],   :name => "tiny"}
+  #  }
+  #}
+
+  has_many :friendships_by_others, :class_name => "Friendship", :foreign_key => 'invited_id', :conditions => "status = #{Friendship::ACCEPTED}"
+  has_many :friendships_by_me, :class_name => "Friendship", :foreign_key => 'inviter_id', :conditions => "status = #{Friendship::ACCEPTED}"
+  
+  has_many :follower_friendships, :class_name => "Friendship", :foreign_key => "invited_id", :conditions => "status = #{Friendship::PENDING}"
+  has_many :following_friendships, :class_name => "Friendship", :foreign_key => "inviter_id", :conditions => "status = #{Friendship::PENDING}"
+  
+  has_many :friends_by_others,  :through => :friendships_by_others, :source => :inviter
+  has_many :friends_by_me, :through => :friendships_by_me, :source => :invited
+  
+  has_many :followers, :through => :follower_friendships, :source => :inviter
+  has_many :followings, :through => :following_friendships, :source => :invited
+  
+  before_create :set_default_icon
+  
+  
+  def friends
+    # Reload associations just to make sure we're working with the current staff. Bad smell!
+    # todo check this... if we don't should reload the relationship to get the test working...
+    (friends_by_others(true) + friends_by_me(true)).uniq
+  end
+  def friendships
+    (friendships_by_others(true) + friendships_by_me(true)).uniq
+  end
+
+  def full_name
+     #todo apply for internationalization
+     first_name.blank? && last_name.blank? ? self.user.login : "#{first_name} #{last_name}".strip
+  end
+
+  def followed_by? profile
+    followers(true).include? profile
+  end
+
+  def follows? profile
+    followings(true).include? profile
+  end
+  def is_friend_of? profile
+    friends.include? profile
+  end
+  def is_related_to? profile
+    me.followed_by?(profile) || me.follows?(profile) || me.is_friend_of?(profile)
+  end
+  
+  def add_follower(follower)
+    if follower.follows? me
+      return false
+    elsif me.follows? follower
+      return add_friend(follower)
+    else
+      flw = Friendship.create(:inviter => follower, :invited => me, :status => Friendship::PENDING)
+      unless flw.new_record?
+        # todo enable send_friendships_notifications? setting per profile
+        # FriendshipMailer.deliver_new_follower(me, follower)  if me.send_friendships_notifications?
+        FriendshipMailer.deliver_new_follower(me, follower) 
+        return true
+      end
+      return false
+    end
+  end
+
+  def add_following(following)
+    following.add_follower(me)
+  end
+
+  def add_friend(friend)
+    relationship = if friend.follows? me
+      find_friendship(friend, me, Friendship::PENDING)
+    elsif friend.followed_by? me
+      find_friendship(me, friend, Friendship::PENDING)
+    else
+      Friendship.create(:inviter => friend, :invited => me, :status => Friendship::PENDING)
+    end
+    relationship.accept!
+    # todo enable send_friendships_notifications? setting per profile
+    # FriendshipMailer.deliver_frienship_validated(relationship.inviter, relationship.invited) if relationship.inviter.send_friendships_notifications?
+    FriendshipMailer.deliver_friendship_validated(relationship.inviter, relationship.invited)
+    return true
+  end
+  def remove_friend(friend)
+    relationships = me.friendships.select{|f| f.inviter == friend  || f.invited == friend }
+    relationships.each{|r| r.destroy}
+  end
+
+  
+  private
+  # Freud will be happy.
+  def me
+    self
+  end
+  
+  def find_friendship(inviter, invited, status)
+     conditions = {:inviter_id => inviter.id, :invited_id => invited.id}
+     conditions.merge!(:status => status) if status
+     Friendship.find(:first, :conditions => conditions)
+  end
+  def set_default_icon
+    unless self.icon
+      if Tog::Config["system.profile.image.default"]
+        default_profile_icon = File.join(RAILS_ROOT, 'public', 'images', Tog::Config["system.profile.image.default"])
+        self.icon = File.new(default_profile_icon)
+      end
+    end
+  end
+end
+

data/app/models/user.rb

@@ -0,0 +1,18 @@
+class User < ActiveRecord::Base
+
+  has_one :profile, :dependent => :destroy
+  has_many :memberships
+  has_many :moderator_memberships, :class_name => 'Membership', 
+                                   :conditions => ['memberships.moderator = ?', true]
+
+  has_many :groups, :through => :memberships, 
+                    :conditions => "memberships.state='active' and groups.state='active'"
+
+  has_many :moderated_groups, :through => :moderator_memberships, 
+                    :conditions => "memberships.state='active' and groups.state='active'", :source => :group
+
+  def name
+      profile.full_name
+  end
+
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+# Add your custom routes here.  If in config/routes.rb you would 
+# add <tt>map.resources</tt>, here you would add just <tt>resources</tt>
+
+# resources :tog_socials

data/db/migrate/001_create_tog_social_tables.rb

@@ -0,0 +1,54 @@
+class CreateTogSocialTables < ActiveRecord::Migration
+  def self.up
+    create_table :profiles do |t|
+      t.integer  :user_id
+      t.string   :first_name
+      t.string   :last_name
+      t.string   :website
+      t.string   :blog
+      t.string   :icon
+      t.timestamps
+    end 
+    User.find(:all).each{|u|
+      profile = Profile.new 
+      profile.user = u
+      profile.save!
+    }
+    
+    create_table :groups do |t|
+      t.string   :name
+      t.string   :description
+      t.string   :image
+      t.string   :state
+      t.boolean  :private
+      t.boolean :moderated, :default => true 
+      t.integer  :user_id
+      t.string   :activation_code, :limit => 40
+      t.datetime :activated_at
+      t.timestamps
+    end
+    
+    create_table :memberships do |t|
+      t.integer  :user_id
+      t.integer  :group_id
+      t.boolean  :moderator
+      t.string   :state
+      t.string   :activation_code, :limit => 40
+      t.datetime :activated_at
+      t.timestamps
+    end
+    create_table :friendships do |t|
+      t.integer  :inviter_id
+      t.integer  :invited_id
+      t.integer  :status
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :friendships
+    drop_table :memberships
+    drop_table :groups
+    drop_table :profiles
+  end
+end

data/test/factories.rb

@@ -0,0 +1,16 @@
+Factory.define :user do |u|
+  u.salt '7e3041ebc2fc05a40c60028e2c4901a81035d3cd'
+  u.crypted_password '00742970dc9e6319f8019fd54864d3ea740f04b1'
+  u.activation_code '8f24789ae988411ccf33ab0c30fe9106fab32e9a'
+  u.state 'pending'
+  u.email {|a| "#{a.login}@example.com".downcase }
+end
+
+Factory.define :profile do |u|
+end
+
+
+Factory.define :group do |g|
+  g.state 'active'
+  #g.author{|author| author.association :user, :login => 'chavez'} 
+end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require 'test_help'
+require 'test/unit'
+
+require 'factory_girl'
+require File.expand_path(File.dirname(__FILE__) + '/factories')
+
+class Test::Unit::TestCase
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+  fixtures :all
+  
+  def assert_difference(object, method = nil, difference = 1)
+    initial_value = object.send(method)
+    yield
+    assert_equal initial_value + difference, object.send(method), "#{object}##{method} should have a difference of #{difference}"
+  end
+
+  def assert_no_difference(object, method, &block)
+    assert_difference object, method, 0, &block
+  end
+  
+end

data/test/unit/group_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GroupTest < Test::Unit::TestCase
+  context "A Group" do
+    
+    setup do
+      @berlusconi = Factory(:user, :login => 'berlusconi')
+      @chavez = Factory(:user, :login => 'chavez')
+      @pornfans = Factory(:group, :name => 'Porn without frontiers', :moderated => false, :author => @chavez)
+    end
+
+    should "should allow to join directly" do
+      @pornfans.join(@berlusconi)
+      assert @pornfans.members.include?(@berlusconi), "The joined user should be on the members list"
+    end
+    
+    should "allow give moderator rights" do
+      @pornfans.join(@berlusconi)
+      assert_no_difference(Membership, :count) do
+        @pornfans.grant_moderator(@berlusconi)
+      end
+      assert_contains @pornfans.moderators, @berlusconi
+    end
+
+    should "allow revoke moderator rights" do
+      @pornfans.join(@berlusconi)
+      assert_no_difference(Membership, :count) do
+        @pornfans.revoke_moderator(@berlusconi)
+      end
+       assert_does_not_contain @pornfans.moderators, @berlusconi
+    end
+    
+    context "that is moderated" do
+      setup do
+        @selectedporn = Factory(:group, :name => 'Porn for V.I.P', :moderated => true, :author => @chavez)
+      end
+    
+      should "not allow to join directly" do
+        assert_difference(Membership, :count) do
+          @selectedporn.join(@berlusconi)
+        end
+        assert !@selectedporn.members.include?(@berlusconi)
+        @selectedporn.activate_membership(@berlusconi)
+        assert @selectedporn.members(true).include?(@berlusconi)
+      end
+    end
+  
+  end
+
+end

data/test/unit/profile_test.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ProfileTest < Test::Unit::TestCase
+  context "A Profile " do
+    setup do
+      @user = Factory(:user, :login => 'chavez')  
+      @user2 = Factory(:user, :login => 'evo')  
+
+      @chavez = Factory(:profile, :first_name => 'Hugo', :last_name => 'Chavez', :user => @user)
+      @evo = Factory(:profile, :first_name => 'Evo', :last_name => 'Morales', :user => @user2)
+    end
+    
+    should "returna full_name correctly base on first_name and last_name" do
+      assert_equal "Hugo Chavez", @chavez.full_name,  "Full name should Hugo Chavez"
+    end  
+    
+    should "return last_name as full_name if first_name is blank" do
+      [nil, ""].each {|value|
+        @chavez.first_name = value
+        assert_equal "Chavez", @chavez.full_name,  "Full name should Chavez if first name is blank"
+      }
+    end
+    should "return login as full_name if first name and last name are blank" do
+      [nil, ""].each {|value|
+        @chavez.first_name = @chavez.last_name = value
+        assert_equal "chavez",  @chavez.full_name, "full_name should defaults to login if first name and last name are blank"
+      }      
+    end
+    
+    should "allow to add a follower" do
+      @chavez.add_follower(@evo)
+      assert @evo.follows?(@chavez), "Evo should follow Chavez"
+      assert @chavez.followed_by?(@evo), "Chavez should be followed by Evo"
+    end
+    
+
+    def test_add_following
+      @evo.add_following(@chavez)
+      assert @evo.follows?(@chavez), "Evo should follow Chavez"
+      assert @chavez.followed_by?(@evo), "Chavez should be followed by Evo"
+    end
+
+    def test_add_follower_twice_has_no_effect
+      assert_difference(Friendship, :count) do
+        @chavez.add_follower(@evo)
+      end
+      assert_no_difference(Friendship, :count) do
+        @chavez.add_follower(@evo)
+      end
+    end
+
+
+    def test_add_follower_from_a_person_im_following_should_convert_the_relationship_on_a_friendship
+      @chavez.add_follower(@evo)
+      @evo.add_follower(@chavez)
+      assert @evo.is_friend_of?(@chavez)
+      assert @chavez.is_friend_of?(@evo)
+    end
+
+    def test_add_friend
+      assert !@evo.is_related_to?(@chavez)
+      assert @evo.add_friend(@chavez)
+      assert @evo.is_friend_of?(@chavez), "Evo and Chavez should be friends"
+      assert @chavez.is_friend_of?(@evo), "Chavez and Evo should be friends"
+    end
+
+    def test_remove_friend
+      assert @evo.add_friend(@chavez)
+      assert @evo.is_friend_of?(@chavez), "Evo and Chavez should be friends"
+      @evo.remove_friend(@chavez)
+      assert !@evo.is_friend_of?(@chavez)
+      assert !@evo.is_related_to?(@chavez)
+    end
+    
+    
+    
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: aitor-tog_social
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Aitor Garcia
+- Roberto Salicio
+- Alberto Molpeceres
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: Tog social
+email: aitor@linkingpaths
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- app/helpers
+- app/models/friendship.rb
+- app/models/group.rb
+- app/models/membership.rb
+- app/models/profile.rb
+- app/models/user.rb
+- app/views
+- config/routes.rb
+- db/migrate/001_create_tog_social_tables.rb
+- tasks
+- test/factories.rb
+- test/test_helper.rb
+- test/unit/group_test.rb
+- test/unit/profile_test.rb
+has_rdoc: true
+homepage: http://github.com/aitor/tog_social
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: tog_social
+test_files: []
+