social_stream 0.4.3 → 0.4.4

data/app/models/permission.rb

@@ -43,10 +43,10 @@
 #
 # Available functions are:
 #
-# +tie+:: apply the permission to the established tie only.
+# nil:: apply the permission to the established tie only.
 #
 #         Example: if the _friend_ relation has the permission
-#         <tt>create activity tie</tt>, the _friend_ can create activities
+#         <tt>create activity nil</tt>, the _friend_ can create activities
 #         attached to this tie only. _Bob_ can create activities only at _Alice_'s
 #         _friend_ level.
 #
@@ -90,17 +90,17 @@ class Permission < ActiveRecord::Base
   # The SQL and ARel conditions for permission queries
   ParameterConditions = {
     :table => {
-      'tie' =>
+      nil =>
         "ties_as.sender_id = ties.sender_id AND ties_as.receiver_id = ties.receiver_id AND ties_as.relation_id = ties.relation_id",
       'weak_ties' =>
-        "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",
+        "ties_as.sender_id = ties.sender_id AND ties_as.receiver_id = ties.receiver_id AND (relations.id = relations_as.id OR relations.ancestry = relations_as.id OR relations.ancestry = (relations_as.ancestry || '/' || relations_as.id) OR relations.ancestry LIKE (relations_as.id || '/%') OR relations.ancestry LIKE (relations_as.ancestry || '/' || relations_as.id || '/%'))",
       'star_ties' =>
         "ties_as.sender_id = ties.sender_id AND ties_as.relation_id = ties.relation_id",
       'weak_star_ties' =>
-        "ties_as.sender_id = ties.sender_id AND relations.lft BETWEEN relations_as.lft AND relations_as.rgt"
+        "ties_as.sender_id = ties.sender_id AND (relations.id = relations_as.id OR relations.ancestry = relations_as.id OR relations.ancestry = (relations_as.ancestry || '/' || relations_as.id) OR relations.ancestry LIKE (relations_as.id || '/%') OR relations.ancestry LIKE (relations_as.ancestry || '/' || relations_as.id || '/%'))"
     },
     :arel => {
-      'tie' => lambda { |as, t|
+      nil => lambda { |as, t|
         # The same sender, receiver and relation
         as[:sender_id].eq(t.sender_id).and(
           as[:receiver_id].eq(t.receiver_id)).and(
@@ -141,7 +141,7 @@ class Permission < ActiveRecord::Base
       else
         ParameterConditions[:table].inject([]){ |result, pc|
           result <<
-            sanitize_sql([ "#{ pc.last } AND permissions.function = ?", pc.first ])
+            "#{ pc.last } AND #{ sanitize_sql('permissions.function' => pc.first) }"
         }.join(" OR ")
       end
     end

data/app/models/profile.rb

@@ -1,6 +1,6 @@
 class Profile < ActiveRecord::Base
   belongs_to :actor
-  
+    
   accepts_nested_attributes_for :actor
   
   validates_presence_of :actor_id

data/app/models/relation/custom.rb

@@ -0,0 +1,111 @@
+# When a new {SocialStream::Models::Subject subject} is created, a initial set
+# of relations is created for him. Afterwards, the {SocialStream::Models::Subject subject}
+# can customize them and adapt them to his own preferences.
+#
+# Default relations are defined at config/relations.yml
+#
+class Relation::Custom < Relation
+  # Default relations are defined in this configuration file
+  CONFIG = File.join(::Rails.root, 'config', 'relations.yml')
+
+  # This is weird. We must call #inspect before has_ancestry for Relation::Custom
+  # to recognize STI
+  inspect
+  has_ancestry
+
+  belongs_to :sphere
+  has_one    :actor, :through => :sphere
+
+  validates_presence_of :name, :sphere_id
+
+  after_create :initialize_tie
+
+  class << self
+    # Relations configuration
+    def config
+      @config ||= YAML.load_file(CONFIG)
+    end
+
+    def defaults_for(actor)
+      cfg_rels = config[actor.subject_type.underscore]
+
+      if cfg_rels.nil?
+        raise "Undefined relations for subject type #{ actor.subject_type }. Please, add an entry to #{ CONFIG }"
+      end
+
+      rels = {}
+
+      cfg_rels.each_pair do |name, cfg_rel|
+        raise("Must associatiate relation #{ cfg_rel['name'] } to a sphere") if cfg_rel['sphere'].blank?
+        sphere = actor.spheres.find_or_create_by_name(cfg_rel['sphere'])
+
+        rels[name] =
+          create! :sphere        => sphere,
+                  :receiver_type => cfg_rel['receiver_type'],
+                  :name =>          cfg_rel['name']
+
+        if (ps = cfg_rel['permissions']).present?
+          ps.each do |p| 
+            rels[name].permissions << 
+              Permission.find_or_create_by_action_and_object_and_function(*p)
+          end 
+        end
+      end
+
+      # Parent, relations must be set after creation
+      # FIXME: Can fix with ruby 1.9 and ordered hashes
+      cfg_rels.each_pair do |name, cfg_rel|
+        rels[name].update_attribute(:parent, rels[cfg_rel['parent']]) if cfg_rel['parent'].present?
+      end
+
+      rels.values
+    end
+
+    # A relation in the top of a strength hierarchy
+    def strongest
+      roots
+    end
+  end
+
+  # Compare two relations
+  def <=> rel
+    return -1 if rel.is_a?(Public)
+
+    if ancestor_ids.include?(rel.id)
+      1
+    elsif rel.ancestor_ids.include?(id)
+      -1
+    else
+      0
+    end
+  end
+
+  # Other relations below in the same hierarchy that this relation
+  def weaker
+    descendants
+  end
+
+  # Relations below or at the same level of this relation
+  def weaker_or_equal
+    subtree
+  end
+
+  # Other relations above in the same hierarchy that this relation
+  def stronger
+    ancestors
+  end
+
+  # Relations above or at the same level of this relation
+  def stronger_or_equal
+    path
+  end
+
+
+  private
+
+  # Create reflexive tie for the owner of this {Relation::Custom custom relation}
+  def initialize_tie
+    ties.create! :sender => sphere.actor,
+                 :receiver => sphere.actor
+  end
+end

data/app/models/relation/public.rb

@@ -0,0 +1,42 @@
+class Relation::Public < Relation
+  attr_accessor :actor
+
+  after_create :initialize_tie
+
+  scope :actor, lambda { |a|
+    joins(:ties).merge(Tie.sent_by(a))
+  }
+
+  class << self
+    def default_for(actor)
+      create! :actor => actor
+    end
+
+    # The {Relation::Public} belonging to actor
+    def of(actor)
+      actor(actor).first
+    end
+  end
+
+  # A {Relation::Public public relation} is always the weakest
+  def <=>(relation)
+    1
+  end
+
+  # The name of public relation
+  def name
+    I18n.t('relation.public.name')
+  end
+
+  # Are we supporting custom permissions for {Relation::Public}? Not by the moment.
+  def allow?(user, action, object)
+    action == 'read' && object == 'activity'
+  end
+
+  private
+
+  def initialize_tie
+    ties.create! :sender => actor,
+                 :receiver => actor
+  end
+end

data/app/models/relation.rb

@@ -3,14 +3,6 @@
 # resources (transactions, lending and borrowing), messages or conversations, 
 # physical connection and affiliation to same organizations.
 #
-# = Default relations
-#
-# When a new {SocialStream::Models::Subject subject} is created, a initial set
-# of relations is created for him. Afterwards, the {SocialStream::Models::Subject subject}
-# can customize them and adapt them to his own preferences.
-#
-# Default relations are defined at config/relations.yml
-#
 # = Strength hierarchies
 #
 # Relations are arranged in strength hierarchies, denoting that some ties between
@@ -27,66 +19,18 @@
 # See the documentation of {Permission} for more details on permission definition.
 #
 class Relation < ActiveRecord::Base
-  # The actor this relation belongs to
-  attr_accessor :actor
-
-  # Default relations are defined in this configuration file
-  CONFIG = File.join(::Rails.root, 'config', 'relations.yml')
-
-  acts_as_nested_set
-
   scope :mode, lambda { |st, rt|
     where(:sender_type => st, :receiver_type => rt)
   }
 
-  validates_presence_of :name
-
   has_many :relation_permissions, :dependent => :destroy
   has_many :permissions, :through => :relation_permissions
 
   has_many :ties, :dependent => :destroy
 
   before_create :initialize_sender_type
-  after_create  :initialize_ties
 
   class << self
-    # Relations configuration
-    def config
-      @config ||= YAML.load_file(CONFIG)
-    end
-
-    def defaults_for(actor)
-      cfg_rels = config[actor.subject_type.underscore]
-
-      if cfg_rels.nil?
-        raise "Undefined relations for subject type #{ actor.subject_type }. Please, add an entry to #{ CONFIG }"
-      end
-
-      rels = {}
-
-      cfg_rels.each_pair do |name, cfg_rel|
-        rels[name] =
-          Relation.create! :actor         => actor,
-                           :receiver_type => cfg_rel['receiver_type'],
-                           :name =>          cfg_rel['name']
-
-        if (ps = cfg_rel['permissions']).present?
-          ps.each do |p| 
-            rels[name].permissions << 
-              Permission.find_or_create_by_action_and_object_and_function(*p)
-          end 
-        end
-      end
-
-      # Parent, relations must be set after creation
-      # FIXME: Can fix with ruby 1.9 and ordered hashes
-      cfg_rels.each_pair do |name, cfg_rel|
-        rels[name].update_attribute(:parent, rels[cfg_rel['parent']]) if cfg_rel['parent'].present?
-      end
-
-      rels.values
-    end
-
     # Get relation from object, if possible
     #
     # Options::
@@ -120,31 +64,6 @@ class Relation < ActiveRecord::Base
         normalize(r, options).id
       end
     end
-
-    # A relation in the top of a strength hierarchy
-    def strongest
-      root
-    end
-  end
-
-  # Other relations below in the same hierarchy that this relation
-  def weaker
-    descendants
-  end
-
-  # Relations below or at the same level of this relation
-  def weaker_or_equal
-    self_and_descendants
-  end
-
-  # Other relations above in the same hierarchy that this relation
-  def stronger
-    ancestors
-  end
-
-  # Relations above or at the same level of this relation
-  def stronger_or_equal
-    self_and_ancestors
   end
 
   # Relation class scoped in the same mode that this relation
@@ -160,12 +79,5 @@ class Relation < ActiveRecord::Base
 
     self.sender_type = actor.subject_type
   end
-
-  # Create reflexive ties for this actor
-  def initialize_ties
-    return if actor.blank?
-
-    ties.create! :sender   => actor,
-                 :receiver => actor
-  end
 end
+

data/app/models/sphere.rb

@@ -0,0 +1,7 @@
+class Sphere < ActiveRecord::Base
+  belongs_to :actor
+  
+  has_many :relations
+
+  validates_presence_of :name
+end

data/app/models/tie.rb

@@ -1,16 +1,19 @@
-# A tie is a link between two {Actor actors} with a {Relation relation}.
+# A {Tie} is a link between two {Actor Actors} with a {Relation}.
 #
-# The first {Actor actor} is the sender of the {Tie tie}. The second {Actor actor}
-# is the receiver of the {Tie tie}.
+# The first {Actor} is the sender of the {Tie}. The second {Actor}
+# is the receiver of the {Tie}.
 #
 # = {Tie Ties} and {Activity activities}
-# {Activity Activities} are attached to {Tie ties}. 
-# * The sender of the tie is the target of the {Activity}.
-#   The wall-profile of an {Actor} is composed by the resources assigned to
-#   the {Tie Ties} in which the {Actor} is the sender.
-# * The receiver {Actor} of the {Tie} is the author of the {Activity}.
+# {Activity Activities} are attached to {Tie ties}. When _Alice_ post in _Bob_'s wall,
+# the {Activity} is attached to the {Tie} from _Alice_ to _Bob_
+#
+# * The sender of the {Tie} 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}.
+#   originates the {Activity} (for example: add as contact).
+#
+# * The receiver {Actor} of the {Tie} is the receiver of the {Activity}.
+#   The {Activity} will appear in the wall of the receiver, depending on the permissions
+#
 # * The {Relation} sets up the mode in which the {Activity} is shared.
 #   It sets the rules, or {Permission Permissions}, by which {Actor} have access
 #   to the {Activity}.
@@ -35,7 +38,6 @@
 # = Scopes
 # There are several scopes defined:
 #
-# original:: ties created by actors. It excludes ties created in the weaker set.
 # sent_by(actor):: ties whose sender is actor
 # received_by(actor):: ties whose receiver is actor
 # sent_or_received_by(actor):: the union of the former
@@ -45,13 +47,12 @@
 #           is replied if there is a tie from b to a
 #
 class Tie < ActiveRecord::Base
-  attr_accessor :message
-  attr_accessor :relation_permissions
-
   # Facilitates relation assigment along with find_relation callback
   attr_writer :relation_name
   # Facilitates new relation permissions assigment along with find_or build_relation callback
-  attr_reader :relation_permissions
+  attr_accessor :relation_sphere, :relation_permissions
+  # Send a message when this tie is created
+  attr_accessor :message
 
   belongs_to :sender,
              :class_name => "Actor",
@@ -65,9 +66,7 @@ class Tie < ActiveRecord::Base
   has_many :tie_activities, :dependent => :destroy
   has_many :activities, :through => :tie_activities
 
-  scope :original, where(:original => true)
-
-  scope :recent, order("#{ quoted_table_name }.created_at DESC")
+  scope :recent, order("ties.created_at DESC")
 
   scope :sent_by, lambda { |a|
     where(:sender_id => Actor.normalize_id(a))
@@ -94,17 +93,25 @@ class Tie < ActiveRecord::Base
       where("ties.sender_id = ties_2.receiver_id AND ties.receiver_id = ties_2.sender_id")
   }
 
+  scope :replying, lambda { |tie|
+    where(:sender_id => tie.receiver_id).
+    where(:receiver_id => tie.sender_id)
+  }
+
   scope :following, lambda { |a|
     where(:receiver_id => Actor.normalize_id(a)).
       joins(:relation => :permissions).merge(Permission.follow)
   }
 
+  scope :public_relation, lambda {
+    joins(:relation).where('relations.type' => 'Relation::Public')
+  }
+
   validates_presence_of :sender_id, :receiver_id, :relation
 
   before_validation :find_or_build_relation
 
   before_create :save_relation
-  after_create :complete_weak_set
   after_create :create_activity
   after_create :send_message
 
@@ -185,12 +192,6 @@ class Tie < ActiveRecord::Base
   # We get the set of ties that are allowing certain permission
   #
 
-  scope :with_permissions, lambda { |action, object|
-    joins(:relation => :permissions).
-      where('permissions.action' => action).
-      where('permissions.object' => object)
-  }
-
   # Given a given permission (action, object), the access_set are the set of ties that grant that permission.
   scope :access_set, lambda { |tie, action, object|
     with_permissions(action, object).
@@ -201,13 +202,13 @@ class Tie < ActiveRecord::Base
     query = 
       select("DISTINCT ties.*").
         from("ties INNER JOIN relations ON relations.id = ties.relation_id, ties as ties_as INNER JOIN relations AS relations_as ON relations_as.id = ties_as.relation_id INNER JOIN relation_permissions ON relations_as.id = relation_permissions.relation_id INNER JOIN permissions ON permissions.id = relation_permissions.permission_id").
-        where("permissions.action = ?", action).
-        where("permissions.object = ?", object)
+        where("permissions.action" => action).
+        where("permissions.object" => object)
 
     conds = Permission.parameter_conditions
     # FIXME: Patch to support public activities
     if action == 'read' && object == 'activity'
-      conds = sanitize_sql([ "( #{ conds } ) OR relations.name = ?", "public" ])
+      conds = "( #{ conds } ) OR #{ sanitize_sql('relations.type' => 'Relation::Public') }"
     end
 
     query.where(conds)
@@ -229,13 +230,38 @@ class Tie < ActiveRecord::Base
   end
 
   # Does this tie allows user to perform action on object?
-  def allows?(user, action, object)
-    # FIXME: Patch to support public activities
-    return true if relation.name == 'public' && action == 'read' && object == 'activity'
+  #
+  # We allow all actions on reflexive ties
+  def allow?(user, action, object)
+    return true if Actor.normalize_id(user) == sender_id && reflexive?
+
+    # FIXME: Patch to support public activities.
+    if relation.is_a?(Relation::Public)
+      return relation.allow?(user, action, object)
+    end
 
     allowing(user, action, object).any?
   end
 
+  scope :with_permissions, lambda { |action, object|
+    joins(:relation => :permissions).
+      where('permissions.action' => action).
+      where('permissions.object' => object)
+  }
+
+  # All the ties that are allowed to follow activities from this tie
+  def followers
+    followers = Tie.received_by(sender).with_permissions('follow', nil)
+
+    unless relation.is_a?(Relation::Public)
+      allowed = access_set('read', 'activity').map(&:receiver_id)
+
+      followers = followers.sent_by(allowed)
+    end
+
+    followers
+  end
+
   private
 
   # Before validation callback
@@ -243,8 +269,8 @@ class Tie < ActiveRecord::Base
   def find_or_build_relation
     return if find_relation || relation_name.blank?
 
-    self.relation = Relation.new :name => relation_name,
-                                 :actor => sender
+    self.relation = Relation::Custom.new :name   => relation_name,
+                                         :sphere => nil
 
     relation.permission_ids = relation_permissions
   end
@@ -265,34 +291,21 @@ class Tie < ActiveRecord::Base
   end
  
 
-  # After create callback
-  # Creates ties with weaker relations in the strength hierarchy of this tie
-  def complete_weak_set
+  # After create callback to create related {Activity}
+  def create_activity
     return if reflexive?
 
-    relation.weaker.each do |r|
-      if relation_set(:relations => r).blank?
-        t = relation_set.build :relation => r,
-                               :original => false
-        t.save!
-      end
-    end
+    Activity.create! :_tie => self, :activity_verb => ActivityVerb[contact_verb]
   end
-  
-  def create_activity
-    return if ! original? || reflexive?
 
-    Activity.create! :_tie => self, :activity_verb => ActivityVerb[contact_verb]
+   def contact_verb
+    replied? ? "make-friend" : "follow"
   end
- 
+
   # Send a message to the receiver of the tie
   def send_message
-    if original? && message.present?
+    if message.present?
       sender.send_message(receiver, message, I18n.t("activity.verb.#{ contact_verb }.#{ receiver.subject_type }.message", :name => sender.name))
     end
   end
-
-  def contact_verb
-    replied? ? "make-friend" : "follow"
-  end
 end

data/app/models/tie_activity.rb

@@ -1,4 +1,42 @@
 class TieActivity < ActiveRecord::Base
   belongs_to :activity
   belongs_to :tie
+
+  after_create :disseminate
+
+  private
+  
+  # Make a copy to all the ties that are both interesed and allowed to reach the activity
+  def disseminate
+    return unless original?
+
+    followers = tie.followers
+
+    # FIXME: here we need to check moderation and diffussion of the received activity.
+    #
+    # Sometimes, diffussion is not required, i.e. when the sender adds the receiver as contact
+    # Other times, the receiver must explicitly allow to post to her wall, and the dissemination permissions
+    # can control who else related with the receiver should receive the activity
+    receiver_ties =
+      Tie.
+        with_permissions('create', 'activity').
+        replying(tie)
+
+    if receiver_ties.present?
+      followers |= receiver_ties
+
+      # Disseminate to the followers of the receiver
+      receiver_ties.each do |t|
+        followers |= t.followers
+      end
+    end
+
+    # All the ties following the activities attached to this tie, allowed to read
+    # this activity
+    followers.each do |t|
+      self.class.create!(:activity_id => activity_id,
+                         :tie => t,
+                         :original => false)
+    end
+  end
 end

data/app/views/activities/_new.html.erb

@@ -1,4 +1,4 @@
-<% if receiver.active_ties_for(current_subject).any? %>
+<% if receiver.activity_ties_for?(current_subject) %>
   <% content_for :javascript do %>
 
     securityImage = "<%= escape_javascript(image_tag('btn/btn_security.png', :id => 'security_image', :alt => 'security')) %>";
@@ -11,14 +11,14 @@
 
   <div id="activities_header" class="content_size">
     <%= form_for Post.new(:text => t('activity.input'),
-                          :_activity_tie_id => receiver.active_ties_for(current_subject).first.id),
+                          :_activity_tie_id => receiver.activity_ties_for(current_subject).first.id),
                           :remote => true  do |f| %>
       <%= f.text_field :text, :id => "input_activities", :size => 85 %>
       <div id="activities_share_btn">
 
-        <% if receiver.active_ties_for(current_subject).count > 1 %>
+        <% if receiver.activity_ties_for(current_subject).count > 1 %>
           <div id="securities">
-            <%= f.select :_activity_tie_id, receiver.active_ties_for(current_subject).sort{ |t, u| t.relation <=> u.relation }.map{ |t| [ t.relation_name, t.id ] }, {}, :id => 'security' %>
+            <%= f.select :_activity_tie_id, receiver.activity_ties_for(current_subject).sort{ |t, u| t.relation <=> u.relation }.map{ |t| [ t.relation_name, t.id ] }, {}, :id => 'security' %>
           </div>
         <% else %>
           <%= f.hidden_field :_activity_tie_id %>

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

@@ -1,11 +1,11 @@
 <div class="activity_options">
   <ul class="activity_options" >
     <li><div class="post_time_ago"><%= t('time.ago', :time => time_ago_in_words(activity.created_at)) %></div></li>
-    <% if activity.is_root? && activity.receiver.sent_ties_allowing(current_subject, 'create', 'activity').any? %>
+    <% if activity.is_root? && activity.receiver.activity_ties_for?(current_subject) %>
     <li><div class="verb_comment"> · <%= link_to t('activity.to_comment'), "#", :class => "to_comment" %> </div></li>
     <% end %>
     <li><div class="verb_like" id="like_<%= dom_id(activity) %>"> · <%= link_like(activity)%></div></li>
-    <% if activity.direct_object.present? %>
+    <% if activity.direct_object.present? && !activity.direct_object.is_a?(Actor) %>
       <li><div class="verb_delete"> · <%= link_to t('activity.delete'), activity.direct_object , :confirm => t('confirm_delete', :scope => activity.direct_object.class.to_s.underscore), :method => :delete,  :remote => true %> </div></li>
     <% end %>
   </ul>

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

@@ -5,6 +5,9 @@
 <%= javascript_include_tag 'avatars.js' %>
 <% end %>
 
+<% content_for :title do%>
+  <%= current_subject.name %>
+<% end%>
 <% content_for :sidebar do %>
   <%= render :partial => 'home/sidebar' %>
 <% end %>
@@ -18,7 +21,7 @@
 <div class="space_center"></div>
 <div class="space_center"></div>
 <% unless(@avatars.empty? || (@avatars.first.present? && @avatars.first.id.blank?)) %>
-  <h2>Use your saved avatars ...</h2>
+  <h2><%=t('avatar.text.use') %></h2>
   <div class="space_center"></div>
   <div class="space_center"></div>
   <div class="avatars">
@@ -46,7 +49,7 @@
   <br class="clearfloat" />
   <div class="space_center"></div>
   <div class="space_center"></div>
-  <h2>... our upload a new one</h2>
+  <h2><%=t('avatar.text.new') %></h2>
 <% else %>
   <h2><%= t('avatar.new') %></h2>
 <% end %>

data/app/views/comments/_new.html.erb

@@ -1,8 +1,8 @@
-<% if activity.receiver.sent_ties_allowing(current_subject, 'create', 'activity').any? %>
+<% if activity.receiver.activity_ties_for?(current_subject) %>
   <div class="activity_new_comment">
  <%= form_for Comment.new(:text => t('comment.input'),
                           :_activity_tie_id =>
-                            activity.receiver.sent_ties_allowing(current_subject, 'create', 'activity').first.id,
+                            activity.receiver.activity_ties_for(current_subject).first.id,
                           :_activity_parent_id => activity.id),
               :remote => true do |f| %>
    <%= f.hidden_field :_activity_tie_id %>