social_stream 0.4.1 → 0.4.2

data/app/controllers/ties_controller.rb

@@ -1,17 +1,16 @@
 class TiesController < InheritedResources::Base
   respond_to :html, :xml, :js
 
-  before_filter :authenticate_user!, :only => :suggestion
+  before_filter :authenticate_user!
+
+  def create
+    create! do |format|
+      format.html { redirect_to resource.receiver_subject }
+    end
+  end
 
   def suggestion
     @tie = current_subject.suggestion
     render :layout  => false
   end
-  
-  def create
-      super do |format|
-        format.html { redirect_to resource.receiver_subject }
-      end
-  end
-  
 end

data/app/controllers/users_controller.rb

@@ -1,51 +1,27 @@
-class UsersController < ApplicationController
+class UsersController < InheritedResources::Base
+  respond_to :html, :xml, :js
+  
   def index
-    if params[:search]
-      @users = User.search("%"+params[:search]+"%").paginate(:per_page => 10, :page => params[:page])
-    else
-      if params[:letter] && params[:letter]!="undefined"
-        @users = User.search(params[:letter]+"%").paginate(:per_page => 10, :page => params[:page])
-      else
-        @users = User.alphabetic.paginate(:per_page => 10, :page => params[:page])
-      end
+    @users = User.alphabetic.
+                  letter(params[:letter]).
+                  search(params[:search]).
+                  paginate(:per_page => 10, :page => params[:page])
+
+    index! do |format|
+      format.html { render :layout => (user_signed_in? ? 'application' : 'frontpage') }
     end
   end
 
-  def show
-    @user = User.find_by_slug!(params[:id])
-    
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  # { render :xml => @user }
-    end
-	end
+  # Supported through devise
+  def new; end; def create; end
+  # Not supported yet
+  def destroy; end
 
-  def edit
-    @user = User.find_by_slug!(params[:id])
+  protected
 
-    respond_to do |format|
-      format.html # edit.html.erb
-      format.xml  { render :xml => @user }
-    end
+  # Overwrite resource method to support slug
+  # See InheritedResources::BaseHelpers#resource
+  def resource
+    @user ||= end_of_association_chain.find_by_slug!(params[:id])
   end
-  
-  def update
-    
-    @user = User.find_by_slug!(params[:id])
-
-    respond_to do |format|
-      if @user.update_attributes(params[:user])
-        #format.html { redirect_to(@user, :notice => 'User was successfully updated.') }
-        #format.html { render :action => "edit", :notice => 'User was successfully updated.' }
-        format.html { render :partial => "right_show", :notice => 'User was successfully updated.' }
-        format.xml  { head :ok }
-        format.js 
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
-        format.js
-      end
-    end
-  end
-
 end

data/app/helpers/location_helper.rb

@@ -0,0 +1,34 @@
+module LocationHelper
+	
+  # Renders the location stack for your view. You can add as many stack levels as you wish.
+  #
+  # Usage:  
+  # <%= location(level1,leve2,level3,level4,....) %> 
+  #
+  # Output: 
+  # base > level1 > level2 > level3 > level 4
+  #
+  # Default configuration:
+  # base => "You are here" ("location.base" on config/locales)
+  # separator => ">" ("location.separator" on config/locales)
+  #
+  # Styles and HTML wrapping:
+  # partial => location/_location.html.erb 
+  #
+  # Example:  
+  # 	Render a location with a two leves depth:
+  #
+  #   	<%= location(link_to(leve1.name, level1.url),link_to(leve2.name, level2.url)) %>
+  #
+	def location(*stack)
+		location_body = t('location.base')
+		stack.collect {|level|
+			location_body << t('location.separator') + level
+		}
+
+		location_div = capture do
+			render :partial => "location/location", :locals=>{:location_body => location_body}
+		end
+	end
+
+end

data/app/helpers/subjects_helper.rb

@@ -1,4 +1,9 @@
 module SubjectsHelper
+  # Return a link to this subject with the name
+  def link_name(subject, options = {})
+    link_to subject.name, subject, options
+  end
+
   # Define the toolbar content for your view. There are two typical cases, depending on the value of
   # options[:profile]
   # * If present, render the profile menu for the {SocialStream::Models::Subject subject}
@@ -29,13 +34,25 @@ module SubjectsHelper
       menu_options[options[:option]] = capture(&block)
     end
 
-    content_for(:toolbar) do
+    content = capture do
       if options[:profile]
         render :partial => 'subjects/toolbar_profile', :locals => { :subject => options[:profile] }
       else
         render :partial => 'subjects/toolbar_home'
       end
     end
+
+    case request.format
+    when Mime::JS
+      <<-EOJ
+      $('#toolbar').html("#{ escape_javascript(content) }");
+      EOJ
+    else
+      content_for(:toolbar) do
+        content
+      end
+    end
+    
   end
 
   # Cache menu options for toolbar

data/app/models/activity.rb

@@ -5,9 +5,17 @@
 # the relation in which the activity is transferred
 #
 # == Wall
-# The Activity.wall(ties) scope provides all the activities attached to a set of ties
+# The Activity.wall(type, ties) scope provides all the activities attached to a set of ties
+# 
+# There are two types of wall, :home and :profile. Check {Actor#wall} for more information
 #
 class Activity < ActiveRecord::Base
+  # The direction of the sender and receiver subjects compared with the attached tie
+  SUBJECT_DIRECTIONS = {
+    :direct  => %w(follow make-friend),
+    :inverse => %w(like post update)
+  }
+
   has_ancestry
 
   belongs_to :activity_verb
@@ -28,21 +36,19 @@ class Activity < ActiveRecord::Base
 
   after_create :like_direct_object
 
-  scope :home_wall, lambda { |ties|
-    select("DISTINCT activities.*").
-      roots.
-      joins(:tie_activities).
-      where('tie_activities.tie_id' => ties).
-      order("created_at desc")
-  }
+  scope :wall, lambda { |type, ties|
+    q = select("DISTINCT activities.*").
+          roots.
+          joins(:tie_activities).
+          where('tie_activities.tie_id' => ties).
+          order("created_at desc")
 
-  scope :profile_wall, lambda { |ties|
-    select("DISTINCT activities.*").
-      roots.
-      joins(:tie_activities).
-      where('tie_activities.tie_id' => ties).
-      where('tie_activities.original' => true).
-      order("created_at desc")
+    # Profile wall is composed by original TieActivities. Not original are copies for followers
+    if type == :profile
+      q = q.where('tie_activities.original' => true)
+    end
+
+    q
   }
 
   # After an activity is created, it is associated to ties
@@ -59,32 +65,36 @@ class Activity < ActiveRecord::Base
     self.activity_verb = ActivityVerb[name]
   end
 
-  # The author of the activity is the receiver of the tie
+  # The {Actor} author of this activity
   #
-  # This method provides the actor. Use sender_subject for the subject (user, group, etc..)
+  # This method provides the {Actor}. Use {#sender_subject} for the {SocialStream::Models::Subject Subject}
+  # ({User}, {Group}, etc..)
   def sender
-    tie.receiver
+    direct? ? tie.sender : tie.receiver
   end
 
-  # The author of the activity is the receiver of the tie
+  # The {SocialStream::Models::Subject Subject} author of this activity
   #
-  # This method provides the subject (user, group, etc...). Use sender for the actor.
+  # This method provides the {SocialStream::Models::Subject Subject} ({User}, {Group}, etc...).
+  # Use {#sender} for the {Actor}.
   def sender_subject
-    tie.receiver_subject
+    direct? ? tie.sender_subject : tie.receiver_subject
   end
 
-  # The wall where the activity is shown belongs to the sender of the tie
+  # The wall where the activity is shown belongs to receiver
   #
-  # This method provides the actor. Use sender_subject for the subject (user, group, etc..)
+  # This method provides the {Actor}. Use {#receiver_subject} for the {SocialStream::Models::Subject Subject}
+  # ({User}, {Group}, etc..)
   def receiver
-    tie.sender
+    direct? ? tie.receiver : tie.sender
   end
 
-  # The wall where the activity is shown belongs to the sender of the tie
+  # The wall where the activity is shown belongs to the receiver
   #
-  # This method provides the subject (user, group, etc...). Use sender for the actor.
+  # This method provides the {SocialStream::Models::Subject Subject} ({User}, {Group}, etc...).
+  # Use {#receiver} for the {Actor}.
   def receiver_subject
-    tie.sender_subject
+    direct? ? tie.receiver_subject : tie.sender_subject
   end
 
   # The comments about this activity
@@ -123,6 +133,18 @@ class Activity < ActiveRecord::Base
     direct_activity_object.try(:object)
   end
 
+  # The title for this activity in the stream
+  def title view
+    case verb
+    when "follow", "make-friend"
+      I18n.t "activity.verb.#{ verb }.title",
+             :subject => view.link_name(sender_subject),
+             :contact => view.link_name(receiver_subject)
+    when "post"
+      view.link_name sender_subject
+    end.html_safe
+  end
+
   private
 
   # Assign to ties of followers
@@ -147,4 +169,22 @@ class Activity < ActiveRecord::Base
 
     activity_objects << parent.direct_activity_object
   end
+
+  private
+
+  # The {#sender} and the {#receiver} of the {Activity} depends on its {ActivityVerb}
+  #
+  # Contact activities such as make-friend or follow are direct. They have the same sender
+  # and receiver as their tie. On the other hand, post activities are inverse. The sender of
+  # the activity is the receiver of the tie and the receiver of the activity is the sender of
+  # the tie
+  def direct?
+    if SUBJECT_DIRECTIONS[:direct].include?(verb)
+      true
+    elsif SUBJECT_DIRECTIONS[:inverse].include?(verb)
+      false
+    else
+      raise "Unknown direction for verb #{ verb }"
+    end
+  end
 end

data/app/models/activity_verb.rb

@@ -1,6 +1,6 @@
 class ActivityVerb < ActiveRecord::Base
   # Activity Strems verbs
-  Available = %w( post update like make_friend)
+  Available = %w(follow like make-friend post update)
 
   validates_uniqueness_of :name
 

data/app/models/actor.rb

@@ -19,14 +19,12 @@ class Actor < ActiveRecord::Base
   acts_as_messageable
   acts_as_url :name, :url_attribute => :slug
   
-  has_attached_file :logo,
-                    :styles => { :tie => "30x30>",
-                                 :actor => '35x35>',
-                                 :profile => '94x94' },
-                    :default_url => "/images/:attachment/:style/:subtype_class.png"
-  
   has_one :profile, :dependent => :destroy
-  
+
+  has_many :avatars,
+  		  :validate => true,
+  		  :autosave => true
+  		  
   has_many :sent_ties,
            :class_name => "Tie",
            :foreign_key => 'sender_id',
@@ -44,7 +42,31 @@ class Actor < ActiveRecord::Base
   has_many :receivers,
            :through => :sent_ties,
            :uniq => true
-  
+
+  scope :alphabetic, order('actors.name')
+
+  scope :letter, lambda { |param|
+    if param.present?
+      where('actors.name LIKE ?', "#{ param }%")
+    end
+  }
+
+  scope :search, lambda { |param|
+    if param.present?
+      where('actors.name LIKE ?', "%#{ param }%")
+    end
+  }
+
+  scope :distinct_initials, select('DISTINCT SUBSTR(actors.name,1,1) as initial').order("initial ASC")
+
+  scope :contacted_to, lambda { |a|
+    joins(:sent_ties).merge(Tie.received_by(a))
+  }
+
+  scope :contacted_from, lambda { |a|
+    joins(:received_ties).merge(Tie.sent_by(a))
+  }
+ 
   after_create :initialize_ties
   
   after_create :create_profile
@@ -109,16 +131,16 @@ class Actor < ActiveRecord::Base
     relations.find_by_name(name)
   end
   
-  # All the actors this one has relation with
+  # All the {Actor actors} this one has relation with
   #
   # Options:
-  # * subject_type: Filter by the class of the subjects.
-  # * direction: senders or receivers
+  # * type: Filter by the class of the contacts.
+  # * direction: sent or received
   # * relations: Restrict the relations of considered ties
   # * include_self: False by default, don't include this actor as subject even they have ties with themselves.
   #
-  def actors(options = {})
-    subject_types   = Array(options[:subject_type] || self.class.subtypes)
+  def contact_actors(options = {})
+    subject_types   = Array(options[:type] || self.class.subtypes)
     subject_classes = subject_types.map{ |s| s.to_s.classify }
     
     as = Actor.select("DISTINCT actors.*").
@@ -127,12 +149,12 @@ class Actor < ActiveRecord::Base
     
     
     case options[:direction]
-      when :senders
-      as = as.joins(:sent_ties).merge(Tie.received_by(self))
-      when :receivers
-      as = as.joins(:received_ties).merge(Tie.sent_by(self))
+      when :sent
+        as = as.contacted_from(self)
+      when :received
+        as = as.contacted_to(self)
     else
-      raise "actors in both directions is not supported yet"
+      raise "contact actors in both directions are not supported yet"
     end
     
     if options[:include_self].blank?
@@ -140,20 +162,20 @@ class Actor < ActiveRecord::Base
     end
     
     if options[:relations].present?
-      as &= Tie.related_by(options[:relations])
+      as = as.merge(Tie.related_by(options[:relations]))
     end
     
     as
   end
   
-  # All the subject actors that send or receive at least one tie to this actor
+  # All the {SocialStream::Models::Subject subjects} that send or receive at least one {Tie} to this {Actor}
   #
-  # When passing a block, it will be evaluated for the actors query, allowing to add 
+  # When passing a block, it will be evaluated for building the actors query, allowing to add 
   # options before the mapping to subjects
   #
-  # See actors for options
-  def subjects(options = {})
-    as = actors(options)
+  # See #contact_actors for options
+  def contacts(options = {})
+    as = contact_actors(options)
     
     if block_given?
       as = yield(as)
@@ -189,7 +211,7 @@ class Actor < ActiveRecord::Base
     # Candidates are all the instance of "type" minus all the subjects
     # that are receiving any tie from this actor
     candidates = candidates_classes.inject([]) do |cs, klass|
-      cs += klass.all - subjects(:subject_type => klass, :direction => :receivers)
+      cs += klass.all - contacts(:type => klass, :direction => :sent)
       cs -= Array(subject) if subject.is_a?(klass)
       cs
     end
@@ -210,6 +232,10 @@ class Actor < ActiveRecord::Base
     sent_ties.received_by(a)
   end
   
+  def ties_to?(a)
+    ties_to(a).present?
+  end
+  
   # All the ties this actor has with subject that support permission
   def sent_ties_allowing(subject, action, objective)
     return [] if subject.blank?
@@ -235,21 +261,42 @@ class Actor < ActiveRecord::Base
                          :receiver_id => i }
   end
   
-  # The set of activities in the wall of this actor, includes all the activities
-  # from the ties the actor has access to
+  # The set of {Activity activities} in the wall of this {Actor}.
   #
-  def home_wall
-    Activity.home_wall ties
+  # There are two types of walls:
+  # home:: includes all the {Activity activities} from this {Actor} and their followed {Actor actors}
+  #             See {Permission permissions} for more information on the following support
+  # profile:: The set of activities in the wall profile of this {Actor}, it includes only the
+  #           activities from the ties of this actor that can be read by the subject
+  #
+  # Options:
+  # :for:: the subject that is accessing the wall
+  # :relation:: show only activities that are attached at this relation level. For example,
+  #             the wall for members of the group.
+  #             
+  def wall(type, options = {})
+    ts = ties
+
+    if type == :profile
+      # FIXME: show public activities
+      return [] if options[:for].blank?
+
+      ts = ts.allowing(options[:for], 'read', 'activity')
+    end
+
+    if options[:relation].present?
+      ts = ts.related_by(Relation.normalize(options[:relation], :sender => self))
+    end
+
+    Activity.wall type, ts
   end
   
-  # The set of activities in the wall profile of this actor, includes the activities
-  # from the ties of this actor that can be read by user
-  #
-  def profile_wall(user)
-    # FIXME: show public activities
-    return [] if user.blank?
-    
-    Activity.profile_wall ties.allowing(user, 'read', 'activity')
+  def logo
+    avatar!.logo
+  end
+
+  def avatar!
+    avatars.active.first || avatars.build
   end
   
   private
@@ -260,4 +307,5 @@ class Actor < ActiveRecord::Base
                         :relation => r
     end
   end
+  
 end