social_stream-base 0.5.2 → 0.6.0

data/app/models/actor.rb

@@ -28,24 +28,33 @@ class Actor < ActiveRecord::Base
            :validate => true,
            :autosave => true
   		  
-  has_many :sent_ties,
-           :class_name => "Tie",
+  has_many :sent_contacts,
+           :class_name  => 'Contact',
            :foreign_key => 'sender_id',
-           :dependent => :destroy
+           :dependent   => :destroy
+
+  has_many :received_contacts,
+           :class_name  => 'Contact',
+           :foreign_key => 'receiver_id',
+           :dependent   => :destroy
+
+  has_many :sent_ties,
+           :through => :sent_contacts,
+           :source  => :ties
   
   has_many :received_ties,
-           :class_name => "Tie",
-           :foreign_key => 'receiver_id',
-           :dependent => :destroy
+           :through => :received_contacts,
+           :source  => :ties
   
   has_many :senders,
-           :through => :received_ties,
+           :through => :received_contacts,
            :uniq => true
   
   has_many :receivers,
-           :through => :sent_ties,
+           :through => :sent_contacts,
            :uniq => true
 
+  has_many :relations
   has_many :spheres
 
   has_many :relation_customs,
@@ -75,13 +84,20 @@ class Actor < ActiveRecord::Base
   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).intended)
+    joins(:sent_contacts).merge(Contact.active.received_by(a))
   }
 
   scope :contacted_from, lambda { |a|
-    joins(:received_ties).merge(Tie.sent_by(a).intended)
+    joins(:received_contacts).merge(Contact.active.sent_by(a))
   }
- 
+
+  scope :followed_by, lambda { |a|
+    select("DISTINCT actors.*").
+      joins(:received_ties => { :relation => :permissions }).
+      merge(Contact.sent_by(a)).
+      merge(Permission.follow)
+  }
+
   after_create :create_initial_relations
   
   after_create :save_or_create_profile
@@ -123,29 +139,12 @@ class Actor < ActiveRecord::Base
     end
   end
   
-  
-  
   # The subject instance for this actor
   def subject
     subtype_instance ||
     activity_object.try(:object)
   end
-  
-  # All the ties sent or received by this actor
-  def ties
-    Tie.sent_or_received_by(self)
-  end
 
-  # The relations that belong to this actor.
-  #
-  # The are both {Relation::Custom} and {Relation::Public} so
-  # we get them from the reciprocal ties
-  def relations
-    Relation.
-      joins(:ties).
-      merge(Tie.sent_by(self).received_by(self))
-  end
-  
   # A given relation defined and managed by this actor
   def relation_custom(name)
     relation_customs.find_by_name(name)
@@ -187,7 +186,7 @@ class Actor < ActiveRecord::Base
     end
     
     if options[:relations].present?
-      as = as.merge(Tie.related_by(options[:relations]))
+      as = as.joins(:ties).merge(Tie.related_by(options[:relations]))
     end
     
     as
@@ -199,7 +198,7 @@ class Actor < ActiveRecord::Base
   # options before the mapping to subjects
   #
   # See #contact_actors for options
-  def contacts(options = {})
+  def contact_subjects(options = {})
     as = contact_actors(options)
     
     if block_given?
@@ -208,6 +207,11 @@ class Actor < ActiveRecord::Base
     
     as.map(&:subject)
   end
+
+  # Return a contact to subject. Create it if it does not exist
+  def contact_to!(subject)
+    Contact.find_or_create_by_sender_id_and_receiver_id id, Actor.normalize_id(subject)
+  end
   
   # This is an scaffold for a recomendations engine
   #
@@ -227,16 +231,16 @@ class Actor < ActiveRecord::Base
   # @return [Contact]
   def suggestion(options = {})
     candidates_types =
-    options[:type].present? ?
-    Array(options[:type]) :
-    self.class.subtypes
+      ( options[:type].present? ?
+          Array(options[:type]) :
+          self.class.subtypes )
     
     candidates_classes = candidates_types.map{ |t| t.to_s.classify.constantize }
     
     # 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 - contacts(:type => klass, :direction => :sent)
+      cs += klass.all - contact_subjects(:type => klass.to_s.underscore, :direction => :sent)
       cs -= Array(subject) if subject.is_a?(klass)
       cs
     end
@@ -245,98 +249,124 @@ class Actor < ActiveRecord::Base
     
     return nil unless candidate.present?
     
-    Contact.new self, candidate.actor.id
+    Contact.new :sender => self, :receiver => candidate.actor
   end
   
-  # Set of ties sent by this actor received by a
-  def ties_to(a)
-    sent_ties.received_by(a).intended
+  # Set of ties sent by this actor received by subject
+  def ties_to(subject)
+    sent_ties.merge(Contact.received_by(subject))
   end
 
-  # Get the first of the ties created to a, or create a new one with the {Relation::Public}
-  def ties_to!(a)
-    ties_to(a).present? ?
-      ties_to(a) :
-      Array(sent_ties.create!(:receiver => a,
-                              :relation => relation_public))
+  def ties_to?(subject)
+    ties_to(subject).present?
   end
-  
+
+ 
   def ties_to?(a)
     ties_to(a).present?
   end
 
-  # The sent {Tie ties} by this {Actor} that grant subject the permission to perform action on object
-  def allow(subject, action, object = nil)
-    return [] if subject.blank?
-
-    sent_ties.allowing(subject, action, object)
-  end
-
-  # Does this {Actor} have any {Tie} to subject that grants her the permission of performing action on object
-  def allow?(subject, action, object = nil)
-    allow(subject, action, object).any?
-  end
-  
   # Can this actor be represented by subject. Does she has permissions for it?
   def represented_by?(subject)
     return false if subject.blank?
 
     self.class.normalize(subject) == self ||
-      allow?(subject, 'represent')
+      sent_ties.
+        merge(Contact.received_by(subject)).
+        joins(:relation => :permissions).
+        merge(Permission.represent).
+        any?
   end
 
-  # The set of ties from this {Actor} to itself.
-  def reflexive_ties
-    sent_ties.received_by(self)
+  # The relations that allow attaching an activity to them. This method is used for caching
+  def active_relations
+    @active_relations ||= { :sender => {}, :receiver => {} }
   end
 
-  # This Actor's public {Tie}
-  def public_tie
-    reflexive_ties.related_by(relation_public).first
+  # An {Activity} can be shared with multiple {audicences Audience}, which corresponds to a {Relation}.
+  #
+  # This method returns all the {relations Relation} that this actor can use to broadcast an Activity
+  #
+  # Options:
+  # from:: limit the relations to one side, from the :sender or the :receiver of the activity
+  #
+  def activity_relations(subject, options = {})
+    return relations if Actor.normalize(subject) == self
+
+    case options[:from]
+    when :sender
+      sender_activity_relations(subject)
+    when :receiver
+      receiver_activity_relations(subject)
+    else
+      sender_activity_relations(subject) +
+        receiver_activity_relations(subject)
+    end
   end
 
-  # Find a tie to subject with the {#relation_public}
-  def public_tie_to(subject)
-    sent_ties.received_by(subject).related_by(relation_public).first
+  # Are there any activity_relations present?
+  def activity_relations?(*args)
+    activity_relations(*args).any?
   end
 
-  # Find or create a tie to subject with the {#relation_public}
-  def public_tie_to!(subject)
-    public_tie_to(subject) ||
-      sent_ties.create!(:receiver_id => Actor.normalize_id(subject),
-                        :relation_id => relation_public.id,
-                        :intended    => false)
+  # Relations from this actor that can be read by subject
+  def sender_activity_relations(subject)
+    active_relations[:sender][subject] ||=
+      Relation.allow(subject, 'read', 'activity', :owner => self)
   end
 
-  # The ties that allow attaching an activity to them. This method is used for caching
-  def active_ties
-    @active_ties ||= {}
+  def receiver_activity_relations(subject)
+    active_relations[:receiver][subject] ||=
+      Relation.allow(self, 'create', 'activity', :owner => subject)
   end
 
-  # This {Actor} #allow s subject to create activities and subject has at least one tie to subject
-  def activity_ties_for(subject)
-    active_ties[subject] ||=
-      ( allow?(subject, 'create', 'activity') ?
-        subject.ties_to!(self) :
-        [] )
+  # Builds a hash of options their spheres as keys
+  def grouped_activity_relations(subject)
+    rels = activity_relations(subject)
+
+    spheres =
+      rels.map{ |r| r.respond_to?(:sphere) ? r.sphere : I18n.t('relation_public.name') }.uniq
+
+    spheres.sort!{ |x, y|
+      case x
+      when Sphere
+        case y
+        when Sphere
+          x.id <=> y.id
+        else
+          -1
+        end
+      else
+        1
+      end
+    }
+
+    spheres.map{ |s|
+      case s
+      when Sphere
+        [ s.name, rels.select{ |r| r.respond_to?(:sphere) && r.sphere == s }.sort.map{ |u| [ u.name, u.id ] } ]
+      else
+        [ s, rels.select{ |r| r.is_a?(Relation::Public) }.map{ |u| [ u.name, u.id ] } ]
+      end
+    }
   end
 
-  # Is there any {Tie} for subject to create an activity to this {Actor} ?
-  def activity_ties_for?(subject)
-    activity_ties_for(subject).any?
+  # Is this {Actor} allowed to create a comment on activity?
+  def can_comment?(activity)
+    comment_relations(activity).any?
   end
 
-  def pending_ties
-    @pending_ties ||=
-    received_ties.where('ties.sender_id NOT IN (?)', sent_ties.map(&:receiver_id).uniq).map(&:sender_id).uniq.
-    map{ |i| Tie.new :sender => self,
-                         :receiver_id => i }
+  # Are there any relations that allow this actor to create a comment on activity?
+  def comment_relations(activity)
+    activity.relations.select{ |r| r.is_a?(Relation::Public) } |
+      Relation.allow(self, 'create', 'activity', :in => activity.relations)
   end
 
-  # Build a new {Contact} from each of {#pending_ties}
+  # Build a new {Contact} from each that has not inverse
   def pending_contacts
-    pending_ties.map do |t|
-      Contact.new(self, t.receiver_id)
+    received_contacts.pending.all.map do |c|
+      c.inverse ||
+        c.receiver.contact_to!(c.sender)
     end
   end
   
@@ -354,21 +384,39 @@ class Actor < ActiveRecord::Base
   #             the wall for members of the group.
   #             
   def wall(type, options = {})
-    ts = ties
+    args = {}
 
-    if type == :profile
-      ts = ( options[:for].blank? ?
-               ts.public_relation :
-               ts.allowing(options[:for], 'read', 'activity') )
+    args[:type]  = type
+    args[:owner] = self
+    # Preserve this options
+    [ :for, :object_type ].each do |opt|
+      args[opt]   = options[opt]
     end
 
-    if options[:relation].present?
-      ts = ts.related_by(Relation.normalize(options[:relation], :sender => self))
+    if type == :home
+      args[:followed] = Actor.followed_by(self).map(&:id)
     end
 
-    Activity.wall type, ts
+    # TODO: this is not scalling for sure. We must use a fact table in the future
+    args[:relation_ids] =
+      case type
+      when :home
+        # The relations from followings that can be read
+        Relation.allow(self, 'read', 'activity').map(&:id)
+      when :profile
+        # FIXME: options[:relation]
+        #
+        # The relations that can be read by options[:for]
+        options[:for].present? ?
+          Relation.allow(options[:for], 'read', 'activity').map(&:id) :
+          []
+      else
+        raise "Unknown type of wall: #{ type }"
+      end
+
+    Activity.wall args
   end
-  
+ 
   def logo
     avatar!.logo
   end
@@ -384,7 +432,7 @@ class Actor < ActiveRecord::Base
   end
   
   def liked_by(subject) #:nodoc:
-    likes.joins(:ties).where('tie_activities.original' => true).merge(Tie.sent_by(subject))
+    likes.joins(:contact).merge(Contact.sent_by(subject))
   end
   
   # Does subject like this {Actor}?
@@ -395,7 +443,7 @@ class Actor < ActiveRecord::Base
   # Build a new activity where subject like this
   def new_like(subject)
     a = Activity.new :verb => "like",
-                     :_tie => subject.public_tie_to!(self)
+                     :contact => subject.contact_to!(self)
     
     a.activity_objects << activity_object           
                     
@@ -405,8 +453,12 @@ class Actor < ActiveRecord::Base
   #Returning whether an email should be sent for this object (Message or Notification).
   #Required by Mailboxer gem.
   def should_email?(object)
-    #TODO
-    return true
+    return notify_by_email
+  end
+
+  # Use slug as parameter
+  def to_param
+    slug
   end
   
   private

data/app/models/audience.rb

@@ -0,0 +1,9 @@
+# Every {Activity} is shared with one or more {audiences Audience}.
+#
+# Each {Audience} is equivalent to a {Relation}, which defines the {actors Actor}
+# that are assigned to that relation and the {permissions Permission} granted to
+# that {Audience}
+class Audience < ActiveRecord::Base
+  belongs_to :activity
+  belongs_to :relation
+end

data/app/models/contact.rb

@@ -1,121 +1,143 @@
-# Convenience class for managing all the ties between two
-# actors at once
-class Contact
-  extend ActiveModel::Naming
-
-  ATTRS = [ :message, :relation_ids ]
-
-  attr_accessor :sender, :receiver, :message
-
-  def initialize(sender, receiver)
-    @sender = Actor.normalize(sender)
-    @receiver = Actor.normalize(receiver)
-  end
+# The link between two {Actor actors}
+#
+# Each {Contact} has many {Tie ties}, which determine the kind of the link through {Relation relations}
+#
+# = {Contact Contacts} and {Activity activities}
+# Each {Activity} is attached to a {Contact}. When _Alice_ post in _Bob_'s wall,
+# the {Activity} is attached to the {Contact} from _Alice_ to _Bob_
+#
+# * The sender of the {Contact} is the author of the {Activity}.
+#   It is the user that uploads a resource to the website or the social entity that
+#   originates the {Activity} (for example: add as contact).
+#
+# * The receiver {Actor} of the {Contact} is the receiver of the {Activity}.
+#   The {Activity} will appear in the wall of the receiver, depending on the permissions
+#
+class Contact < ActiveRecord::Base
+  # Send a message when this contact is created or updated
+  attr_accessor :message
+
+  belongs_to :inverse,
+             :class_name => "Contact"
+
+  belongs_to :sender,
+             :class_name => "Actor",
+             :include => SocialStream.subjects
+  belongs_to :receiver,
+             :class_name => "Actor",
+             :include => SocialStream.subjects
+
+  has_many :ties
+  has_many :relations, :through => :ties
+
+  scope :sent_by, lambda { |a|
+    where(:sender_id => Actor.normalize_id(a))
+  }
+
+  scope :received_by, lambda { |a|
+    where(:receiver_id => Actor.normalize_id(a))
+  }
+
+  scope :sent_or_received_by, lambda { |a|
+    where(arel_table[:sender_id].eq(Actor.normalize_id(a)).
+          or(arel_table[:receiver_id].eq(Actor.normalize_id(a))))
+  }
+
+  scope :recent, order("contacts.created_at DESC")
+
+  scope :pending, joins("LEFT JOIN contacts AS inverse_contacts ON inverse_contacts.id = contacts.inverse_id").
+                  where(arel_table[:inverse_id].eq(nil).or(arel_table.alias("inverse_contacts")[:ties_count].eq(0)))
+
+  scope :active, where(arel_table[:ties_count].gt(0))
+
+  validates_presence_of :sender_id, :receiver_id
+
+  after_create :set_inverse
+  after_create :send_message
 
   def sender_subject
-    sender.subject
+    sender.try(:subject)
   end
 
   def receiver_subject
-    receiver.subject
+    receiver.try(:subject)
   end
 
-  def relation_ids
-    @relation_ids ||=
-      sender.ties_to(receiver).map(&:relation_id)
+  # Does this {Contact} have the same sender and receiver?
+  def reflexive?
+    sender_id == receiver_id
   end
 
-  def relation_ids=(ids)
-    # Gotcha related with empty arrays in forms:
-    #
-    # http://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-check_box
-    ids.delete("gotcha")
-
-    @relation_ids =
-      ids.map{ |i|
-        # We must check that sender has those relation
-        sender.relations.find(i).id
-      }
-  end
-
-  def id
-    receiver.id
+  # Find or create the inverse {Contact}
+  def inverse!
+    inverse ||
+      receiver.contact_to!(sender)
   end
 
-  def to_param
-    id
+  # Is not the inverse of this {Contact}
+  def pending?
+    inverse &&
+      inverse.ties_count > 0
   end
 
-  def to_key
-    [id]
+  # The {ActivityVerb} corresponding to this {Contact}, depending on if
+  # it is pending or already replied
+  def verb
+    pending? ? "follow" : "make-friend"
   end
 
-  def update_attributes(attrs)
-    ATTRS.each do |attr|
-      if attrs.key?(attr.to_s)                  # if attrs.key?("message")
-        __send__ "#{ attr }=", attrs[attr.to_s] #   self.message = attrs["message"]
-      end                                       # end
-    end
-
-    save
+  # has_many collection=objects method does not trigger destroy callbacks,
+  # so follower_count will not be updated
+  #
+  # We need to update that status here
+  def relation_ids=(ids)
+    remove_follower(ids)
 
-    # TODO: errors
-    true
+    association(:relations).ids_writer(ids)
   end
 
-  def save
-    @previous = sender.ties_to(receiver).all
-
-    @continued = @previous.select{ |t| relation_ids.include?(t.relation_id) }
-
-    Tie.transaction do
-      # Change previous ties to not intended
-      # Do not destroy them, because there can be activities attached to them
-      (@previous - @continued).each do |t|
-        t.update_attribute :intended, false
-      end
-
-      # Activate tie or create it
-      new_relation_ids = relation_ids - @continued.map(&:relation_id)
+  private
 
-      # There can be old ties that where marked as intented but
-      # now they are activated again
-      @reactivated = sender.
-                     ties_to(receiver).
-                     related_by(new_relation_ids)
+  def remove_follower(ids)
+    # There was no follower
+    return if relation_ids.blank?
 
-      @reactivated.each{ |t| t.update_attribute :intended, true }
-       
-      @new = (new_relation_ids - @reactivated.map(&:relation_id)).map do |i|
-        sender.sent_ties.create! :receiver_id => receiver.id,
-                                 :relation_id => i
-      end
+    ids = ids.map(&:to_i)
 
-      create_activity
-      send_message
-    end
-  end
+    return if ids.sort == relation_ids.sort
 
-  private
+    following = Relation.
+                  where(:id => relation_ids).
+                  joins(:permissions).
+                  merge(Permission.follow).
+                  any?
 
-  # Create the related {Activity}
-  def create_activity
-    return if @previous.present?
+    if following
+      will_follow = Relation.
+                      where(:id => ids).
+                      joins(:permissions).
+                      merge(Permission.follow).
+                      any?
 
-    @new.each do |t|
-      Activity.create! :_tie => t,
-                       :activity_verb => ActivityVerb[verb]
+      if !will_follow
+        receiver.decrement!(:follower_count)
+      end
     end
   end
-
-  def verb
-    @new.first.replied? ? "make-friend" : "follow"
-  end
-
+ 
   # Send a message to the contact receiver
   def send_message
     if message.present?
       sender.send_message(receiver, message, I18n.t("activity.verb.#{ contact_verb }.#{ receiver.subject_type }.message", :name => sender.name))
     end
   end
+
+  def set_inverse
+    inverse = Contact.sent_by(receiver_id).received_by(sender_id).first
+
+    return if inverse.blank?
+
+    update_attribute :inverse_id, inverse.id
+    inverse.update_attribute :inverse_id, id
+  end
 end