social_stream 0.2.3 → 0.3.0

data/.gitignore

@@ -1,3 +1,4 @@
 .bundle
 pkg/*gem
 **.tmp_*
+Gemfile.lock

data/README.rdoc

@@ -43,14 +43,13 @@ This will generate the following:
 * A jquery:install generation for jQuery support
 * A devise:install generation for authentication support
 * An initializer file with configuration for Social Stream.
-* A database seeds file for defining custom Social Stream relations, along with an entry in db/seeds.rb to load it. You can define your own relations at <tt>db/seeds/social_stream.yml</tt>
+* A configuration file for defining custom Social Stream relations. You can define your application default relations at <tt>config/relations.yml</tt>
 * A new application layout
 * A migration providing the database schema
 
-Do not forget to migrate and seed your database
+Do not forget to migrate your database
 
   rake db:migrate
-  rake db:seed
 
 == Actors and Activity Objects
 

data/app/controllers/likes_controller.rb

@@ -17,7 +17,7 @@ class LikesController < ApplicationController
   end
 
   def destroy
-    if (@like = activity!.liked_by(current_user).first)
+    if (@like = activity!.liked_by(current_subject).first)
       @like.destroy
     end
 
@@ -37,7 +37,7 @@ class LikesController < ApplicationController
   end
 
   def tie
-    @tie ||= current_user.sent_ties(:receiver => activity!.receiver,
+    @tie ||= current_subject.sent_ties(:receiver => activity!.receiver,
                                     :relation => activity!.relation).first
   end
 

data/app/controllers/messages_controller.rb

@@ -0,0 +1,3 @@
+class MessagesController < InheritedResources::Base
+  respond_to :html, :xml, :js
+end

data/app/controllers/representations_controller.rb

@@ -0,0 +1,8 @@
+# Changes context for users to represent other subjects
+class RepresentationsController < ApplicationController
+  def create
+    self.current_subject = Representation.new(params[:representation]).subject
+
+    redirect_to(request.referer || home_path)
+  end
+end

data/app/controllers/ties_controller.rb

@@ -4,7 +4,7 @@ class TiesController < InheritedResources::Base
   before_filter :authenticate_user!, :only => :suggestion
 
   def suggestion
-    @tie = current_user.suggestion
+    @tie = current_subject.suggestion
     render :layout  => false
   end
 end

data/app/helpers/activities_helper.rb

@@ -1,11 +1,11 @@
 module ActivitiesHelper
 
-  # Link to 'like' or 'unlike' depending on the like status of the activity to current_user
+  # Link to 'like' or 'unlike' depending on the like status of the activity to current_subject
   # 
   # @param [Activity]
   # @return [String]
   def link_like(activity)
-    if (activity.liked_by?(current_user))
+    if (activity.liked_by?(current_subject))
       link_to t('activity.unlike'), activity_like_path(activity), :method => :delete, :remote => true
     else
       link_to t('activity.like'), activity_like_path(activity), :method => :post, :remote => true

data/app/helpers/ties_helper.rb

@@ -3,26 +3,29 @@ module TiesHelper
     "N contacts in common"
   end
 
-  def tie_link(tie)
-    # FIXME: tie name
-    if tie.relation.granted
-      # There is granted relation, so another user must confirmate it
-      # We need to render ties#new with a message
-      link_to t("#{ tie.relation.name }.new"),
-              new_tie_path("tie[sender_id]" => tie.sender.id,
-                           "tie[receiver_id]" => tie.receiver.id,
-                           "tie[relation_name]" => tie.relation.name),
-              :title => t("#{ tie.relation.name }.confirm_new",
-                          :name => tie.receiver_subject.name),
-              :remote => true
-
+  # Show current ties from current user to actor, if they exist, or provide a link
+  # to create a new tie to actor
+  def ties_to(a)
+    if user_signed_in?
+      if current_subject.ties_to(a).present?
+        current_subject.ties_to(a).first.relation_name
+      else
+        new_tie_link(current_subject.sent_ties.build :receiver_id => Actor.normalize_id(a))
+      end
     else
-      # Tie can be established at once.
-      render :partial => 'ties/form',
-                         :locals => { :tie => tie }
+      link_to t("contact.new.link"), new_user_session_path
     end
   end
 
+  def new_tie_link(tie)
+    link_to t("contact.new.link"),
+            new_tie_path("tie[sender_id]" => tie.sender.id,
+                         "tie[receiver_id]" => tie.receiver.id),
+            :title => t("contact.new.title",
+                        :name => tie.receiver_subject.name),
+            :remote => true
+  end
+
   def link_follow_state
       link_to("Unfollow", home_path)
   end

data/app/models/activity.rb

@@ -17,19 +17,16 @@ class Activity < ActiveRecord::Base
 
   has_one :tie,
           :through => :tie_activities,
-          :conditions => { 'tie_activities.original' => true },
-          :include => [ :sender ]
+          :conditions => { 'tie_activities.original' => true }
 
-  delegate :sender, :receiver, :relation,
-           :sender_subject, :receiver_subject,
-           :to => :tie
+  delegate :relation, :to => :tie
 
   has_many :activity_object_activities,
            :dependent => :destroy
   has_many :activity_objects,
            :through => :activity_object_activities
 
-  scope :wall, lambda { |ties|
+  scope :home_wall, lambda { |ties|
     select("DISTINCT activities.*").
       roots.
       joins(:tie_activities).
@@ -37,6 +34,15 @@ class Activity < ActiveRecord::Base
       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")
+  }
+
   # After an activity is created, it is associated to ties
   attr_accessor :_tie
   after_create :assign_to_ties
@@ -51,6 +57,34 @@ class Activity < ActiveRecord::Base
     self.activity_verb = ActivityVerb[name]
   end
 
+  # The author of the activity is the receiver of the tie
+  #
+  # This method provides the actor. Use sender_subject for the subject (user, group, etc..)
+  def sender
+    tie.receiver
+  end
+
+  # The author of the activity is the receiver of the tie
+  #
+  # This method provides the subject (user, group, etc...). Use sender for the actor.
+  def sender_subject
+    tie.receiver_subject
+  end
+
+  # The wall where the activity is shown belongs to the sender of the tie
+  #
+  # This method provides the actor. Use sender_subject for the subject (user, group, etc..)
+  def receiver
+    tie.sender
+  end
+
+  # The wall where the activity is shown belongs to the sender of the tie
+  #
+  # This method provides the subject (user, group, etc...). Use sender for the actor.
+  def receiver_subject
+    tie.sender_subject
+  end
+
   # The comments about this activity
   def comments
     children.includes(:activity_objects).where('activity_objects.object_type' => "Comment")
@@ -62,7 +96,7 @@ class Activity < ActiveRecord::Base
   end
 
   def liked_by(user) #:nodoc:
-    likes.joins(:ties).where('tie_activities.original' => true) & Tie.sent_by(user)
+    likes.joins(:ties).where('tie_activities.original' => true) & Tie.received_by(user)
   end
 
   # Does user like this activity?
@@ -77,6 +111,7 @@ class Activity < ActiveRecord::Base
 
   private
 
+  # Assign to ties of followers
   def assign_to_ties
     original = tie_activities.create!(:tie => _tie)
     _tie.activity_receivers.each do |t|

data/app/models/activity_object.rb

@@ -1,4 +1,5 @@
 class ActivityObject < ActiveRecord::Base
+  @subtypes_name = :object
   include SocialStream::Models::Supertype
 
   has_many :activity_object_activities, :dependent => :destroy

data/app/models/activity_verb.rb

@@ -12,7 +12,11 @@ class ActivityVerb < ActiveRecord::Base
 
   class << self
     def [] name
-      verb_name(name).first
+      if Available.include?(name)
+        find_or_create_by_name name
+      else
+        raise "ActivityVerb not available: #{ name }"
+      end
     end
   end
 end

data/app/models/actor.rb

@@ -1,5 +1,6 @@
 # An actor is a social entity. This includes individuals, but also groups, departments, organizations even nations or states. Actors are linked by ties.
 class Actor < ActiveRecord::Base
+  @subtypes_name = :subject
   include SocialStream::Models::Supertype
 
   validates_presence_of :name, :subject_type
@@ -12,24 +13,46 @@ class Actor < ActiveRecord::Base
                                  :profile => '94x94' },
                     :default_url => "/images/:attachment/:style/:subtype_class.png"
 
+  has_one :profile, :dependent => :destroy
+
   has_many :sent_ties,
            :class_name => "Tie",
            :foreign_key => 'sender_id',
            :dependent => :destroy
 
-  has_many :senders,
-           :through => :received_ties,
-           :uniq => true
-
   has_many :received_ties,
            :class_name => "Tie",
            :foreign_key => 'receiver_id',
            :dependent => :destroy
 
+  has_many :senders,
+           :through => :received_ties,
+           :uniq => true
+
   has_many :receivers,
            :through => :sent_ties,
            :uniq => true
 
+  after_create :initialize_ties
+
+  after_create :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) }
+      when Actor
+        a.id
+      else
+        a.actor.id
+      end
+    end
+  end
+
   # The subject instance for this actor
   def subject
     subtype_instance ||
@@ -41,68 +64,71 @@ class Actor < ActiveRecord::Base
     Tie.sent_or_received_by(self)
   end
 
-  # All the subject actors of class subject_type that send at least one tie
-  # to this actor
+  # Relations defined and managed by this actor
+  def relations
+    Relation.includes(:ties) & Tie.sent_by(self)
+  end
+
+  # A given relation defined and managed by this actor
+  def relation(name)
+    relations.find_by_name(name)
+  end
+
+  # All the actors this one has relation with
   #
-  # Options::
+  # Options:
+  # * subject_type: Filter by the class of the subjects.
+  # * direction: senders or receivers
   # * 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 sender_subjects(subject_type, options = {})
-    # FIXME: DRY!
-    subject_class = subject_type.to_s.classify.constantize
-
-    cs = subject_class.
-           select("DISTINCT #{ subject_class.quoted_table_name }.*").
-           with_sent_ties &
-           Tie.received_by(self)
+  # * 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)
+    subject_classes = subject_types.map{ |s| s.to_s.classify }
+
+    as = Actor.select("DISTINCT actors.*").
+               where('actors.subject_type' => subject_classes).
+               includes(subject_types)
+
+
+    case options[:direction]
+    when :senders
+      as = as.joins(:sent_ties) & Tie.received_by(self)
+    when :receivers
+      as = as.joins(:received_ties) & Tie.sent_by(self)
+    else
+      raise "actors in both directions is not supported yet"
+    end
 
     if options[:include_self].blank?
-      cs = cs.where("#{ self.class.quoted_table_name }.id != ?", self.id)
+      as = as.where("actors.id != ?", self.id)
     end
 
     if options[:relations].present?
-      cs &=
-        Tie.related_by(Tie.Relation(options[:relations], :mode => [ subject_class, self.subject.class ]))
+      as &= Tie.related_by(options[:relations])
     end
 
-    cs
+    as
   end
 
-  # All the subject actors of class subject_type that receive at least one tie
-  # from this actor
+  # All the subject actors that send or receive at least one tie to this actor
   #
-  # Options::
-  # * 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 receiver_subjects(subject_type, options = {})
-    # FIXME: DRY!
-    subject_class = subject_type.to_s.classify.constantize
-
-    cs = subject_class.
-           select("DISTINCT #{ subject_class.quoted_table_name }.*").
-           with_received_ties &
-           Tie.sent_by(self)
-
-    if options[:include_self].blank?
-      cs = cs.where("#{ self.class.quoted_table_name }.id != ?", self.id)
-    end
+  # When passing a block, it will be evaluated for the actors query, allowing to add 
+  # options before the mapping to subjects
+  #
+  # See actors for options
+  def subjects(options = {})
+    as = actors(options)
 
-    if options[:relations].present?
-      cs &=
-        Tie.related_by(Tie.Relation(options[:relations], :mode => [ subject.class, subject_class ]))
+    if block_given?
+      as = yield(as)
     end
 
-    cs
+    as.map(&:subject)
   end
 
   # This is an scaffold for a recomendations engine
   #
-  SuggestedRelations = {
-    'User'  => 'friend_request',
-    'Group' => 'follower'
-  }
 
   # Make n suggestions
   # TODO: make more
@@ -118,16 +144,17 @@ class Actor < ActiveRecord::Base
   #
   # @return [Tie]
   def suggestion(options = {})
-    candidates_types = options[:type].present? ?
-      Array(options[:type].to_s.classify) :
-      SuggestedRelations.keys
+    candidates_types =
+      options[:type].present? ?
+        Array(options[:type]) :
+        self.class.subtypes
 
-    candidates_classes = candidates_types.map(&:constantize)
+    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 - receiver_subjects(klass)
+      cs += klass.all - subjects(:subject_type => klass, :direction => :receivers)
       cs -= Array(subject) if subject.is_a?(klass)
       cs
     end
@@ -136,38 +163,56 @@ class Actor < ActiveRecord::Base
 
     return nil unless candidate.present?
 
-    sent_ties.build :receiver_id => candidate.actor.id,
-                    :relation => Relation.mode(subject_type, candidate.class).find_by_name(SuggestedRelations[candidate.class.to_s])
+    # Building ties with sent_ties catches them and excludes them from pending ties.
+    # An useful side effect for excluding this ones from pending, but can be weird!
+    # Maybe we must use:
+    # Tie.sent_by(self).build :receiver_id => candidate.actor.id
+    sent_ties.build :receiver_id => candidate.actor.id
   end
 
-  # All the ties this actor has with subject that support activities
-  def active_ties_to(subject)
-    sent_ties.received_by(subject).allowed(self, 'create', 'activity')
+  # Set of ties sent by this actor received by a
+  def ties_to(a)
+    sent_ties.received_by(a)
+  end
+
+  # All the ties this actor has with subject that support permission
+  def sent_ties_allowing(subject, action, objective)
+    return [] if subject.blank?
+
+    sent_ties.allowing(subject, action, objective)
   end
 
   def pending_ties
-    #TODO: optimize by SQL
     @pending_ties ||=
-      received_ties.pending.
-        select{ |t| ! receivers.include?(t.sender) }.
-        map{ |u| Tie.new :sender_id => u.receiver_id,
-                         :receiver_id => u.sender_id,
-                         :relation_id => u.relation.granted_id
-        }
+      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 }
   end
 
   # The set of activities in the wall of this actor, includes all the activities
   # from the ties the actor has access to
   #
-  def wall
-    Activity.wall Tie.allowed(self, 'read', 'activity')
+  def home_wall
+    Activity.home_wall ties
   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 wall_profile(user)
-    Activity.wall ties.allowed(user, 'read', 'activity')
+  def profile_wall(user)
+    # FIXME: show public activities
+    return [] if user.blank?
+
+    Activity.profile_wall ties.allowing(user, 'read', 'activity')
+  end
+
+  private
+
+  def initialize_ties
+    ::SocialStream::Relations.create(subject_type).each do |r|
+      sent_ties.create! :receiver => self,
+                        :relation => r
+    end
   end
 end
 

data/app/models/group.rb

@@ -1,5 +1,19 @@
 class Group < ActiveRecord::Base
+  attr_accessor :_founder
+
   def followers
-    sender_subjects(:user, :relations => 'follower')
+    subjects(:subject_type => :user, :direction => :senders)
+  end
+
+  after_create :create_founder
+
+  private
+
+  def create_founder
+    founder =
+      Actor.find_by_permalink(_founder) || raise("Cannot create group without founder")
+
+    sent_ties.create! :receiver => founder,
+                      :relation => relations.sort.first
   end
 end

data/app/models/message.rb

@@ -0,0 +1,2 @@
+class Message < ActiveRecord::Base
+end

data/app/models/permission.rb

@@ -1,25 +1,26 @@
 # SocialStream provides a sophisticated and powerful system of permissions based on the relations
 # and ties of the social network.
 #
-# Permissions are composed by action, objective and parameterized. Action and objective are classical
+# Permissions are composed by action, objective and function. Action and objective are classical
 # in content management systems, e.g. "create" "activity", "update" "tie", "read" "post"
 #
-# parameterized is a novel feature. It supports applying the permission to certain set of ties.
-# This set of ties changes with the formation of ties in your website.
+# function is a novel feature. It supports applying the permission to certain set of ties.
+# This set of ties changes along with the formation of ties in your website.
 #
-# Permissions is assigned to relations, and through relations, to ties. 
-# When a sender establishes a tie with a receiver, she grants to the receiver the permissions assigned
+# Permissions are assigned to relations, and through relations, to ties. 
+# When a sender establishes a tie with a receiver, she is granting to the receiver the permissions assigned
 # to relation of the tie she has just established. For example, when Alice establishes a "friend" tie
 # to Bob, she is granting him the permissions associated with "friend" relation.
 #
-# One of this permissions can be "read" "activity" "inverse_group_set". This way, Bob will have access
-# to read the activities attached to ties inside the "inverse_group_set", which are the ties from all
-# the "friends" of Alice to Alice herself.
+# One of this permissions can be "read" "activity" "star_set". This way, Bob will have access
+# to read the activities attached to ties inside the "star_set", which are the ties from Alice to her "friends"
 #
 class Permission < ActiveRecord::Base
   has_many :relation_permissions, :dependent => :destroy
   has_many :relations, :through => :relation_permissions
 
+  scope :represent, where(:action => 'represent')
+
   # The SQL and ARel conditions for permission queries
   ParameterConditions = {
     :table => {
@@ -27,16 +28,10 @@ class Permission < ActiveRecord::Base
         "ties_as.sender_id = ties.sender_id AND ties_as.receiver_id = ties.receiver_id AND ties_as.relation_id = ties.relation_id",
       'weak_set' =>
         "ties_as.sender_id = ties.sender_id AND ties_as.receiver_id = ties.receiver_id AND relations.lft BETWEEN relations_as.lft AND relations_as.rgt",
-      'inverse_weak_set' =>
-        "ties_as.sender_id = ties.receiver_id AND ties_as.receiver_id = ties.sender_id AND relations.inverse_id = relations_inverse.id AND relations_inverse.lft BETWEEN relations_as.lft AND relations_as.rgt",
-      'group_set' =>
-        "ties_as.receiver_id = ties.receiver_id AND ties_as.relation_id = ties.relation_id",
-      'inverse_group_set' =>
-        "ties_as.sender_id = ties.receiver_id AND ties_as.relation_id = relations.inverse_id",
-      'weak_group_set' =>
-        "ties_as.receiver_id = ties.receiver_id AND relations.lft BETWEEN relations_as.lft AND relations_as.rgt",
-      'inverse_weak_group_set' =>
-        "ties_as.sender_id = ties.receiver_id AND relations.inverse_id = relations_inverse.id AND relations_inverse.lft BETWEEN relations_as.lft AND relations_as.rgt"
+      'star_set' =>
+        "ties_as.sender_id = ties.sender_id AND ties_as.relation_id = ties.relation_id",
+      'weak_star_set' =>
+        "ties_as.sender_id = ties.sender_id AND relations.lft BETWEEN relations_as.lft AND relations_as.rgt"
     },
     :arel => {
       'tie' => lambda { |as, t|
@@ -51,31 +46,15 @@ class Permission < ActiveRecord::Base
           as[:receiver_id].eq(t.receiver_id)).and(
           as[:relation_id].in(t.relation.stronger_or_equal.map(&:id)))
       },
-      'inverse_weak_set' => lambda { |as, t|
-        # Senders and receivers interchanged, with a stronger or equal relation of the inverse
-        as[:sender_id].eq(t.receiver_id).and(
-          as[:receiver_id].eq(t.sender_id)).and(
-          as[:relation_id].in(Array(t.relation.inverse.try(:stronger_or_equal)).map(&:id)))
-      },
-      'group_set' => lambda { |as, t|
+      'star_set' => lambda { |as, t|
         # The same receiver and relation
-        as[:receiver_id].eq(t.receiver_id).and(
+        as[:sender_id].eq(t.sender_id).and(
           as[:relation_id].eq(t.relation_id))
       },
-      'inverse_group_set' => lambda { |as, t|
-        # Senders to the common receiver in the same relation
-        as[:sender_id].eq(t.receiver_id).and(
-          as[:relation_id].eq(t.relation.inverse_id))
-      },
-      'weak_group_set' => lambda { |as, t|
+      'weak_star_set' => lambda { |as, t|
         # The same receiver with stronger or equal relations
-        as[:receiver_id].eq(t.receiver_id).and(
+        as[:sender_id].eq(t.sender_id).and(
           as[:relation_id].in(t.relation.stronger_or_equal.map(&:id)))
-      },
-      'inverse_weak_group_set' => lambda { |as, t|
-        # Senders to the common receiver with stronger or equal relations
-        as[:sender_id].eq(t.receiver_id).and(
-          as[:relation_id].in(Array(t.relation.inverse.try(:stronger_or_equal)).map(&:id)))
       }
     }
   }
@@ -84,10 +63,10 @@ class Permission < ActiveRecord::Base
     def parameter_conditions(tie = nil)
       if tie.present?
         ParameterConditions[:arel].inject([]) { |conditions, h|
-          # Add the condition 'permissions.parameter = key'
+          # Add the condition 'permissions.function = key'
           # to all arel ParameterConditions
           conditions <<
-            h.last.call(Tie.arel_table, tie).and(arel_table[:parameter].eq(h.first))
+            h.last.call(Tie.arel_table, tie).and(arel_table[:function].eq(h.first))
         }.inject(nil){ |result, pc|
           # Join all ParameterConditions with OR
           result.nil? ? pc : result.or(pc)
@@ -95,7 +74,7 @@ class Permission < ActiveRecord::Base
       else
         ParameterConditions[:table].inject([]){ |result, pc|
           result <<
-            sanitize_sql([ "#{ pc.last } AND permissions.parameter = ?", pc.first ])
+            sanitize_sql([ "#{ pc.last } AND permissions.function = ?", pc.first ])
         }.join(" OR ")
       end
     end

data/app/models/profile.rb

@@ -1,3 +1,3 @@
 class Profile < ActiveRecord::Base
-  belongs_to :user
+  belongs_to :actor
 end