social_stream 0.23.4 → 0.24.0

data/base/app/models/actor.rb

@@ -1,5 +1,5 @@
-# An {Actor} represents a social entity. This includes individuals, but also groups, departments,
-# organizations even nations or states.
+# An {Actor} represents a social entity. This means {User individuals},
+# but also {Group groups}, departments, organizations even nations or states.
 #
 # Actors are the nodes of a social network. Two actors are linked by {Tie Ties}. The
 # type of a {Tie} is a {Relation}. Each actor can define and customize their relations own
@@ -7,11 +7,15 @@
 #
 # Every {Actor} has an Avatar, a {Profile} with personal o group information, contact data, etc.
 #
+# {Actor Actors} perform {ActivityAction actions} (like, suscribe, etc.) on
+# {ActivityObject activity objects} ({Post posts}, {Comment commments}, pictures, events..)
+#
 # = Actor subtypes
 # An actor subtype is called a {SocialStream::Models::Subject Subject}.
-# {SocialStream} provides two actor subtypes, {User} and {Group}, but the
+# {SocialStream::Base} provides two actor subtypes, {User} and {Group}, but the
 # application developer can define as many actor subtypes as required.
-# Actor subtypes are added to +config/initializers/social_stream.rb+
+# Besides including the {SocialStream::Models::Subject} module, Actor subtypes
+# must added to +config/initializers/social_stream.rb+
 #
 #
 class Actor < ActiveRecord::Base
@@ -75,6 +79,10 @@ class Actor < ActiveRecord::Base
            :foreign_key => :owner_id,
            :dependent => :destroy
 
+  has_many :sent_actions,
+           :class_name => "ActivityAction",
+           :dependent  => :destroy
+
   scope :alphabetic, order('actors.name')
 
   scope :letter, lambda { |param|
@@ -117,35 +125,6 @@ class Actor < ActiveRecord::Base
   after_create :save_or_create_profile
   
   class << self
-    # Get actor's id from an object, if possible
-    def normalize_id(a)
-      case a
-      when Integer
-        a
-      when Array
-        a.map{ |e| normalize_id(e) }
-      else
-        Actor.normalize(a).id
-      end
-    end
-    # Get actor from object, if possible
-    def normalize(a)
-      case a
-      when Actor
-        a
-      when Integer
-        Actor.find a
-      when Array
-        a.map{ |e| Actor.normalize(e) }
-      else
-        begin
-          a.actor
-        rescue
-          raise "Unable to normalize actor #{ a.inspect }"        
-        end
-      end
-    end
-
     def find_by_webfinger!(link)
       link =~ /(acct:)?(.*)@/
 
@@ -318,6 +297,17 @@ class Actor < ActiveRecord::Base
     Channel.find_or_create_by_author_id_and_user_author_id_and_owner_id id, id, id
   end
 
+  # Return the {ActivityAction} model to an {ActivityObject}
+  def action_to(activity_object)
+    sent_actions.received_by(activity_object).first
+  end
+
+  # Return the {ActivityAction} model to an {ActivityObject}. Create it if it does not exist
+  def action_to!(activity_object)
+    action_to(activity_object) ||
+      sent_actions.create!(:activity_object => ActivityObject.normalize(activity_object))
+  end
+
   def sent_active_contact_ids
     @sent_active_contact_ids ||=
       load_sent_active_contact_ids

data/base/app/models/contact.rb

@@ -3,7 +3,17 @@
 #
 # {Contact Contacts} are created at convenience (in the case of {Actor#suggestions suggestions},
 # for instance), and they do not mean that there is a real link between those two
-# {SocialStream::Models::Subject Subjects}. Link existance is stored as {Tie Ties}.
+# {SocialStream::Models::Subject Subjects}. Link existance is stored as a {Tie}.
+# When Alice adds Bob as contact, a new {Tie} is created with the {Contact} from Alice to
+# Bob and the {Relation} that Alice chose.
+#
+# == Inverse Contacts
+#
+# Alice has a {Contact} to Bob. The inverse is the {Contact} from {Bob} to {Alice}.
+# Inverse contacts are used to check if contacts are replied, for instance, if Bob added
+# Alice as contact after she did so.
+#
+# Again, the Contact from Bob to Alice must have positive {Tie ties} to be active.
 #
 class Contact < ActiveRecord::Base
   # Send a message when this contact is created or updated
@@ -22,7 +32,8 @@ class Contact < ActiveRecord::Base
            :before_add => :set_user_author
 
   has_many :relations,
-           :through => :ties
+           :through => :ties,
+           :after_remove => :unset_follow_action
 
   scope :sent_by, lambda { |a|
     where(:sender_id => Actor.normalize_id(a))
@@ -112,18 +123,6 @@ class Contact < ActiveRecord::Base
     replied? ? "make-friend" : "follow"
   end
 
-  # has_many collection=objects method does not trigger destroy callbacks,
-  # so follower_count will not be updated
-  #
-  # We need to update that status here
-  #
-  # FIXME: use :after_remove callback
-  # http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#label-Association+callbacks
-  def relation_ids=(ids)
-    remove_follower(ids)
-    association(:relations).ids_writer(ids)
-  end
-
   # Record who creates ties in behalf of a group or organization
   #
   # Defaults to the sender actor, if it is a user
@@ -137,6 +136,13 @@ class Contact < ActiveRecord::Base
     @user_author = (subject.nil? ? nil : Actor.normalize(subject))
   end
 
+  # The sender of this {Contact} has establised positive sent to the receiver
+  #
+  # That means that there exists at least one {Tie} with a positive relation within them
+  def sent?
+    ties_count > 0 && relations.where(:type => Relation.positive_names).any?
+  end
+
   # Is this {Contact} +new+ or +edit+ for {SocialStream::Models::Subject subject} ?
   #
   # action is +new+ when, despite of being created, it has not {Tie ties} or it has a {Tie} with a
@@ -146,11 +152,7 @@ class Contact < ActiveRecord::Base
   # a {Relation::Public public relation}
   #
   def action
-    if ties_count > 0 && relations.where(:type => Relation.positive_names).any?
-      'edit'
-    else
-      replied? ? 'reply' : 'new'
-    end
+    sent? ? 'edit' : ( replied? ? 'reply' : 'new' )
   end
 
   def status
@@ -200,31 +202,18 @@ class Contact < ActiveRecord::Base
     tie.contact.user_author = @user_author
   end
 
-  def remove_follower(ids)
-    # There was no follower
-    return if relation_ids.blank?
-
-    ids = ids.map(&:to_i)
-
-    return if ids.sort == relation_ids.sort
-
-    following = Relation.
-                  where(:id => relation_ids).
-                  joins(:permissions).
-                  merge(Permission.follow).
-                  any?
-
-    if following
-      will_follow = Relation.
-                      where(:id => ids).
-                      joins(:permissions).
-                      merge(Permission.follow).
-                      any?
+  # after_remove callback
+  #
+  # has_many collection=objects method does not trigger destroy callbacks,
+  # so action#follow and follower_count will not be updated
+  #
+  # We need to update that status here
+  #
+  def unset_follow_action(relation)
+    tie = Tie.new :contact => self,
+                  :relation => relation
 
-      if !will_follow
-        receiver.decrement!(:follower_count)
-      end
-    end
+    tie.unset_follow_action
   end
 
   # Send a message to the contact receiver

data/base/app/models/group.rb

@@ -10,11 +10,7 @@ class Group < ActiveRecord::Base
   def profile!
     actor!.profile || actor!.build_profile
   end
-
-  def followers
-    contact_subjects(:subject_type => :user, :direction => :received)
-  end
-  
+ 
   def recent_groups
     contact_subjects(:type => :group, :direction => :sent) do |q|
       q.select("contacts.created_at").
@@ -54,4 +50,4 @@ class Group < ActiveRecord::Base
   end
 end
 
-ActiveSupport.run_load_hooks(:group, Group)
+ActiveSupport.run_load_hooks(:group, Group)

data/base/app/models/relation.rb

@@ -41,7 +41,7 @@
 # It sets the {Audience} that has access to it, and the {Permission Permissions} that rule that access.
 #
 class Relation < ActiveRecord::Base
-  Positive = %w{ custom public }
+  Positive = %w{ custom public follow }
   Negative = %w{ reject }
 
   belongs_to :actor

data/base/app/models/relation/follow.rb

@@ -0,0 +1,14 @@
+# This relation model implements Twitter-like relations:
+# Users just have followers and followings.
+#
+# Use this model setting <tt>config.relation_model = :follow</tt> in your
+# <tt>config/initializers/social_stream.rb</tt>
+class Relation::Follow < Relation::Single
+  class << self
+    def instance
+      first ||
+        create(:permissions => Array(Permission.find_or_create_by_action('follow')))
+    end
+  end
+end
+

data/base/app/models/tie.rb

@@ -64,8 +64,8 @@ class Tie < ActiveRecord::Base
   validate :relation_belongs_to_sender
 
   after_create  :create_activity
-  after_create  :increment_follower_count
-  after_destroy :decrement_follower_count
+  after_create  :set_follow_action
+  after_destroy :unset_follow_action
 
   def relation_name
     relation.try(:name)
@@ -94,43 +94,26 @@ class Tie < ActiveRecord::Base
     positive? && positive_replied?
   end
 
-  private
-
-  # before_create callback
-  #
-  # Create contact activity if this is the first tie
-  def create_activity
-    return if contact.reload.ties_count != 1 || relation.is_a?(Relation::Reject)
-
-    Activity.create! :author        => contact.sender,
-                     :user_author   => contact.user_author,
-                     :owner         => contact.receiver,
-                     :relation_ids  => contact.relation_ids,
-                     :activity_verb => ActivityVerb[contact.verb]
-  end
-
   # after_create callback
   #
-  # Increment the {Actor}'s follower_count
-  def increment_follower_count
+  # Create the {Actor}'s follower_count
+  def set_follow_action
     return if contact.reflexive? ||
               !relation.permissions.include?(Permission.follow.first)
 
-    # Because we allow several ties from the same sender to the same receiver,
-    # we check the receiver does not already have a follower tie from this sender
-    return if Tie.sent_by(sender).
-                  received_by(receiver).
-                  with_permissions('follow', nil).
-                  where("ties.id != ?", id).
-                  present?
+    action = sender.action_to!(receiver)
+
+    return if action.follow?
 
-    receiver.increment!(:follower_count)
+    action.update_attribute(:follow, true)
   end
 
-  # after_destroy callback
+  # after_remove callback
   #
   # Decrement the {Actor}'s follower_count
-  def decrement_follower_count
+  #
+  # This method needs to be public to be call from {Contact}'s after_remove callback
+  def unset_follow_action
     return if contact.reflexive? ||
               !relation.permissions.include?(Permission.follow.first)
 
@@ -141,7 +124,24 @@ class Tie < ActiveRecord::Base
                   with_permissions('follow', nil).
                   present?
 
-    receiver.decrement!(:follower_count)
+    action = sender.action_to!(receiver)
+
+    action.update_attribute(:follow, false)
+  end
+
+  private
+
+  # before_create callback
+  #
+  # Create contact activity if this is the first tie
+  def create_activity
+    return if contact.reload.ties_count != 1 || relation.is_a?(Relation::Reject)
+
+    Activity.create! :author        => contact.sender,
+                     :user_author   => contact.user_author,
+                     :owner         => contact.receiver,
+                     :relation_ids  => contact.relation_ids,
+                     :activity_verb => ActivityVerb[contact.verb]
   end
 
   def relation_belongs_to_sender

data/base/app/models/user.rb

@@ -1,5 +1,13 @@
 require 'devise/orm/active_record'
 
+# Every social network must have users, and a social network builder couldn't be the exception.
+#
+# Social Stream uses the awesome gem {Devise https://github.com/plataformatec/devise}
+# for managing authentication
+#
+# Almost all the logic of the interaction between {User} and the rest of classes in Social Stream
+# is done through {SocialStream::Models::Subject} and {Actor}
+#
 class User < ActiveRecord::Base
   include SocialStream::Models::Subject
 

data/base/app/views/activities/_options.html.erb

@@ -23,5 +23,4 @@
                       :remote => true %> 
       </div>
     <% end %>
-  </ul>
 </div>

data/base/app/views/activity_actions/_follow_form.html.erb

@@ -0,0 +1,10 @@
+<%= form_for toggle_follow_action(activity_object),
+             :html => { :class => "follow_form-#{ dom_id activity_object }" },
+             :remote => true do |f| %>
+  <% if f.object.new_record? %>
+    <%= f.hidden_field :activity_object_id %>
+  <% end %>
+  <%= f.hidden_field :follow %>
+
+  <%= f.submit t("#{ activity_object.object_type.underscore }.activity_action.#{ f.object.follow ? 'follow' : 'unfollow' }", :default => "activity_action.#{ f.object.follow ? 'follow' : 'unfollow' }") %>
+<% end %>

data/base/app/views/activity_actions/_follow_sentence.html.erb

@@ -0,0 +1,3 @@
+<div class="follow_sentence-<%= dom_id activity_object %>">
+  <%= followers_sentence activity_object %>
+</div>

data/base/app/views/activity_actions/_update_form.js.erb

@@ -0,0 +1,2 @@
+$('.follow_form-<%= dom_id(activity_object) %>').replaceWith("<%= escape_javascript render(:partial => 'activity_actions/follow_form', :locals => { :activity_object => activity_object }) %>");
+$('.follow_sentence-<%= dom_id(activity_object) %>').replaceWith("<%= escape_javascript render(:partial => 'activity_actions/follow_sentence', :locals => { :activity_object => activity_object }) %>");

data/base/app/views/activity_actions/create.js.erb

@@ -0,0 +1 @@
+<%= render :partial => 'update_form', :locals => { :activity_object => @activity_object } %>

data/base/app/views/activity_actions/update.js.erb

@@ -0,0 +1 @@
+<%= render :partial => 'update_form', :locals => { :activity_object => @activity_action.activity_object } %>

data/base/app/views/avatars/index.html.erb

@@ -1,4 +1,4 @@
-<% toolbar :profile => current_subject %>
+<% toolbar :profile, :subject => current_subject %>
 
 <% content_for :title do%>
   <%= current_subject.name %>

data/base/app/views/cheesecake/index.html.erb

@@ -2,7 +2,7 @@
   <%= t('contact.other')%>
 <%end%>
 
-<% toolbar :option => :contacts %>
+<% toolbar :home, :option => :contacts %>
 
 <% location link_to(t("contact.other"),contacts_path) %>
 <div id="cheesecake">

data/base/app/views/contacts/_link_follow.html.erb

@@ -0,0 +1,12 @@
+<div class="<%= follow_link_class contact %>">
+  <% if contact.sent? %>
+    <%= t 'contact.following' %>
+    <%= form_tag follower_path(contact), :method => :delete, :remote => true do |f| %>
+      <%= submit_tag t('contact.unfollow') %>
+    <% end %>
+  <% else %>
+    <%= form_tag follower_path(contact), :method => :put, :remote => true do |f| %>
+      <%= submit_tag t('contact.follow') %>
+    <% end %>
+  <% end %>
+</div>

data/base/app/views/contacts/edit.html.erb

@@ -1,4 +1,4 @@
-<% toolbar :profile => @contact.receiver_subject, :option => 'contacts' %>
+<% toolbar :profile, :subject => @contact.receiver_subject, :option => 'contacts' %>
 
 <% location link_to(t("contact.#{ @contact.action }.title", :name => @contact.receiver.name),
                      edit_contact_path(@contact.to_param)) %>

data/base/app/views/contacts/index.html.erb

@@ -4,7 +4,7 @@
 
 <% sidebar %>
 
-<% toolbar :option => :contacts %>
+<% toolbar :home, :option => :contacts %>
 
 <div id="my_conferences">
   <div id="contacts" class="block">

data/base/app/views/contacts/index.js.erb

@@ -1,3 +1,3 @@
 $('#list_contacts_ajax').html("<%= escape_javascript(render :partial => "contacts/index") %>");
 
-<% toolbar :option => :contacts %>
+<% toolbar :home, :option => :contacts %>