vkhater-social_stream-base 0.11.2

data/app/models/relation.rb

@@ -0,0 +1,169 @@
+# A relation defines a type of {Tie} between two {Actor Actors}. From social literature, 
+# {Relation Relations} can be affective (friendship, liking, respect), formal or biological
+# (authority, kinship), transfer of material resources (transactions, lending and borrowing),
+# messages or conversations, physical connection and affiliation to same organizations.
+#
+# = Relation types defined in {SocialStream Social Stream}
+#
+# All the above cases could be supported in {SocialStream Social Stream}.
+# Nevertheless, the following {Relation Relations} are defined. All of them inherit from the
+# {Relation} class:
+#
+# {Relation::Custom}:: user-defined {Relation}. Every {SocialStream::Models::Subject Subject}
+#                      is able to define their own {Relation::Custom Custom relation},
+#                      giving them a custom name 
+#                      (for instance: friend, colleague, partner, buddy) and {Permission Permissions}.
+# {Relation::Public}:: default {Relation} for ocassional {Tie Ties}.
+# {Relation::Reject}:: the {SocialStream::Models::Subject Subject} does not want to add the other
+#                      as a contact. A new {Tie} is created using this {Relation}
+#
+# You can define new {Relation Relations} in your application. Just create a new class and
+# inherit from {Relation}. This class already supports
+# {http://api.rubyonrails.org/classes/ActiveRecord/Base.html#label-Single+table+inheritance Single Table Inheritance (STI)}.
+#
+# = Relations and link building
+#
+# When a {SocialStream::Models::Subject Subject} creates a new link to other
+# {SocialStream::Models::Subject Subject}, she must specify one or serveral {Relation Relations}
+# for that link. (friend, colleague, {Relation::Public} or {Relation::Reject}.
+# A new {Tie} will be created for each {Relation}
+#
+# = Permissions
+#
+# {SocialStream::Models::Subject Subjects} assign {Permission permissions} to {Relation Relations}.
+# This way, when establishing {Tie ties}, they are granting permissions to their contacts.
+#
+# See the documentation of {Permission} for more details on permission definition.
+#
+# = {Activity Activities} and {Relation Relations}
+#
+# Each {Activity} can be attached to one or more {Relation relations}.
+# 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 }
+  Negative = %w{ reject }
+
+  belongs_to :actor
+
+  has_many :relation_permissions, :dependent => :destroy
+  has_many :permissions, :through => :relation_permissions
+
+  has_many :ties, :dependent => :destroy
+  has_many :contacts, :through => :ties
+
+  has_many :audiences, :dependent => :destroy
+  has_many :activities, :through => :audiences
+
+  validates_presence_of :actor_id
+
+  scope :actor, lambda { |a|
+    where(:actor_id => Actor.normalize_id(a))
+  }
+
+  scope :mode, lambda { |st, rt|
+    where(:sender_type => st, :receiver_type => rt)
+  }
+
+  before_create :initialize_sender_type
+
+  class << self
+    # Get relation from object, if possible
+    #
+    # Options::
+    # sender:: The sender of the tie
+    def normalize(r, options = {})
+      case r
+      when Relation
+        r
+      when String
+        if options[:sender]
+          options[:sender].relation_custom(r)
+        else
+          raise "Must provide a sender when looking up relations from name: #{ options[:sender] }"
+        end
+      when Integer
+        Relation.find r
+      when Array
+        r.map{ |e| Relation.normalize(e, options) }
+      else
+        raise "Unable to normalize relation #{ r.class }: #{ r.inspect }"
+      end
+    end
+
+    def normalize_id(r, options = {})
+      case r
+      when Integer
+        r
+      when Array
+        r.map{ |e| Relation.normalize_id(e, options) }
+      else
+        normalize(r, options).id
+      end
+    end
+
+    # Positive relation names: [ 'Relation::Custom', 'Relation::Public' ]
+    def positive_names
+      Positive.map{ |r| "Relation::#{ r.classify }" }
+    end
+
+    # Negative relations: [ 'Relation::Reject' ]
+    def negative_names
+      Negative.map{ |r| "Relation::#{ r.classify }" }
+    end
+
+    # All the relations that allow subject to perform action
+    #
+    # Options:
+    #   in:: Limit possible relations to a set
+    #   public_relations:: include also {Relation::Public} whose activities can always be read
+    def allow(subject, action, object, options = {})
+      q = 
+        select("DISTINCT relations.*").
+        joins(:contacts).
+        joins(:permissions)
+
+      conds =
+        Permission.arel_table[:action].eq(action).and(Permission.arel_table[:object].eq(object))
+
+      # Relation::Public permissions cannot be customized yet
+      if action == 'read' && object == 'activity' && (options[:public].nil? || options[:public])
+        conds = conds.or(Relation.arel_table[:type].eq('Relation::Public'))
+      end
+
+      # Add in condition
+      if ! options[:in].nil?
+        conds = conds.and(Relation.arel_table[:id].in(Relation.normalize_id(Array(options[:in]))))
+      end
+
+      # subject conditions
+      conds = conds.and(Contact.arel_table[:receiver_id].eq(Actor.normalize_id(subject)))
+
+      q.where(conds)
+    end
+
+    def allow?(*args)
+      allow(*args).to_a.any?
+    end
+  end
+
+  # Relation class scoped in the same mode that this relation
+  def mode
+    Relation.mode(sender_type, receiver_type)
+  end
+
+  # Is this {Relation} a Positive one?
+  def positive?
+    self.class.positive_names.include?(self.class.to_s)
+  end
+
+  private
+
+  # Before create callback
+  def initialize_sender_type
+    return if actor.blank?
+
+    self.sender_type = actor.subject_type
+  end
+end
+

data/app/models/relation/custom.rb

@@ -0,0 +1,112 @@
+# 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 :actor
+
+  validates_presence_of :name, :actor_id
+  validates_uniqueness_of :name, :scope => :actor_id
+
+  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] =
+          create! :actor =>         actor,
+                  :name  =>         cfg_rel['name'],
+                  :receiver_type => cfg_rel['receiver_type']
+
+        if (ps = cfg_rel['permissions']).present?
+          ps.each do |p| 
+            p.push(nil) if p.size == 1
+
+            rels[name].permissions << 
+              Permission.find_or_create_by_action_and_object(*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']])
+      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
+
+  # JSON compatible with SocialCheesecake
+  def to_cheesecake_hash(options = {})
+    { :name => name }.tap do |hash|
+      if options[:subsector]
+        hash[:actors] = ties.map{ |t| [t.contact.receiver_id] }.uniq
+      else
+        hash[:subsectors] = ( weaker.present? ?
+                              weaker.map{ |w| w.to_cheesecake_hash(:subsector => true) } :
+                              Array.wrap(to_cheesecake_hash(:subsector => true)) )
+      end
+    end
+  end
+end

data/app/models/relation/public.rb

@@ -0,0 +1,11 @@
+class Relation::Public < Relation::Single
+  # A {Relation::Public public relation} is always the weakest
+  def <=>(relation)
+    1
+  end
+
+  # Are we supporting custom permissions for {Relation::Public}? Not by the moment.
+  def allow?(user, action, object)
+    action == 'read' && object == 'activity'
+  end
+end

data/app/models/relation/reject.rb

@@ -0,0 +1,3 @@
+class Relation::Reject < Relation::Single
+end
+

data/app/models/relation/single.rb

@@ -0,0 +1,22 @@
+# Common methods for single relations, like {Relation::Public} and {Relation::Reject}
+#
+# Unlike {Relation::Custom}, {SocialStream::Models::Subject subjects} have only one of
+# these {Relation relations}.
+#
+class Relation::Single < Relation
+  class << self
+    def default_for(actor)
+      create! :actor => actor
+    end
+
+    # The {Relation::Public} belonging to actor
+    def of(actor)
+      actor(actor).first
+    end
+  end
+
+  # The name of public relation
+  def name
+    I18n.t("relation_#{ self.class.name.split("::").last.underscore }.name")
+  end
+end

data/app/models/relation_permission.rb

@@ -0,0 +1,4 @@
+class RelationPermission < ActiveRecord::Base
+  belongs_to :relation
+  belongs_to :permission
+end

data/app/models/tie.rb

@@ -0,0 +1,147 @@
+# A {Tie} is a link between two {Actor Actors},
+# and therefore, two {SocialStream::Models::Subject Subjects}.
+#
+# It is made up with a {Contact} and a {Relation}. The {Contact} defines the sender
+# or {Actor} that declares the link, and the receiver or {Actor} that is pointed by
+# the declaration. The {Relation} defines the type of link (friend, colleague,
+# {Relation::Reject}, etc)
+
+# = Authorization
+# When an {Actor} establishes a {Tie} with other, she is granting a set of
+# {Permission Permissions} to them (posting to her wall, reading her posts, etc..)
+# The set of {Permission Permissions} granted are associated with the {Relation} of
+# the {Tie}.
+#
+# = Scopes
+# There are several scopes defined:
+#
+# 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
+# related_by(relation):: ties with this relation. Accepts relation, relation_name,
+#                        integer, array
+#
+class Tie < ActiveRecord::Base
+
+  belongs_to :contact, :counter_cache => true
+
+  has_one :sender,   :through => :contact
+  has_one :receiver, :through => :contact
+
+  belongs_to :relation
+
+  scope :recent, order("ties.created_at DESC")
+
+  scope :sent_by, lambda { |a|
+    joins(:contact).merge(Contact.sent_by(a))
+  }
+  scope :received_by, lambda { |a|
+    joins(:contact).merge(Contact.received_by(a))
+  }
+
+  scope :sent_or_received_by, lambda { |a|
+    joins(:contact).merge(Contact.sent_or_received_by(a))
+  }
+
+  scope :related_by, lambda { |r|
+    if r.present?
+      where(:relation_id => Relation.normalize_id(r))
+    end
+  }
+
+  scope :with_permissions, lambda { |action, object|
+    joins(:relation => :permissions).
+      where('permissions.action' => action).
+      where('permissions.object' => object)
+  }
+
+  validates_presence_of :contact_id, :relation_id
+
+  validate :relation_belongs_to_sender
+
+  after_create  :create_activity
+  after_create  :increment_follower_count
+  after_destroy :decrement_follower_count
+
+  def relation_name
+    relation.try(:name)
+  end
+
+  def sender_subject
+    sender.subject
+  end
+
+  def receiver_subject
+    receiver.subject
+  end
+
+  # The {Tie} is positive if its {Relation} is
+  def positive?
+    relation.positive?
+  end
+
+  # Does this {Tie} have positive {Tie ties} in the other way?
+  def positive_replied?
+    contact.positive_replied?
+  end
+
+  # This {Tie} is {#positive? positive} and {#positive_replied? positive replied}
+  def bidirectional?
+    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! :contact => contact,
+                     :relation_ids => contact.relation_ids,
+                     :activity_verb => ActivityVerb[contact.verb]
+  end
+
+  # after_create callback
+  #
+  # Increment the {Actor}'s follower_count
+  def increment_follower_count
+    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?
+
+    receiver.increment!(:follower_count)
+  end
+
+  # after_destroy callback
+  #
+  # Decrement the {Actor}'s follower_count
+  def decrement_follower_count
+    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 still have a follower tie from this sender
+    return if Tie.sent_by(sender).
+                  received_by(receiver).
+                  with_permissions('follow', nil).
+                  present?
+
+    receiver.decrement!(:follower_count)
+  end
+
+  def relation_belongs_to_sender
+    errors.add(:relation, "must belong to sender") unless
+      contact.sender_id == relation.actor_id
+  end
+end
+
+ActiveSupport.run_load_hooks(:tie, Tie)