social_stream-base 0.5.0

data/app/models/permission.rb

@@ -0,0 +1,180 @@
+# SocialStream provides a sophisticated and powerful system of permissions based on the {Relation relations}
+# of the social network.
+#
+# = Permissions and Relations
+#
+# Permissions are assigned to {Relation Relations}, and through relations, to {Tie 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 her _friend_ relation. Alice's _friend_ relation may
+# have different permissions from Bob's _friend_ relation.
+#
+# = Permissions description
+#
+# Permissions are composed by *action*, *objective* and *function*. Action and objective
+# are typical in content management systems, e.g. <tt>create activity</tt>,
+# <tt>update tie</tt>, <tt>read post</tt>. *function* is a new parameter for social networks
+#
+# == Actions
+#
+# Current available actions are:
+#
+# +create+:: add a new instance of something (activity, tie, post, etc)
+# +read+::   view something
+# +update+::  modify something
+# +destroy+:: delete something
+# +follow+::  subscribe to activity updates from the receiver of the tie
+# +represent+:: give the receiver rights to act as if he were me.
+#
+# == Objectives
+#
+# +activity+:: all the objects in a wall: posts, comments
+#
+# Other objectives currently not implemented could be +tie+, +post+, +comment+ or +message+
+#
+# == Functions
+#
+# Function is a novel feature. It supports applying the permission to other related ties.
+# It is required because the set of ties changes along with the establish of contacts
+# in the website, besides {SocialStream::Models::Subject subjects} can describe and
+# customize their own relations and permissions.
+#
+# Available functions are:
+#
+# nil:: apply the permission to the established tie only.
+#
+#         Example: if the _friend_ relation has the permission
+#         <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.
+#
+# +weak_ties+:: apply the permission to all the related ties with a relation weaker
+#               or equal than this. When a subject establishes a strong ties,
+#               their related ties are established at the same time.
+#
+#               Example: if the _member_ relation of a group has the permission
+#               <tt>create activity weak_ties</tt>, its members
+#               can also create activities attached to the weaker ties of
+#               _acquaintance_ and _public_.
+#               This means than a group _member_ can create activities at different
+#               levels of strength hierarchy, and therefore, with different levels of
+#               access.
+#
+# +star_ties+:: the permission applies to all the ties at the same level of strength,
+#               that is, ties with the same sender and the same relation but
+#               different receivers.
+#
+#               Example: the _public_ relation has the permission
+#               <tt>read activity star_ties</tt>. If _Alice_ has a _public_ tie with
+#               _Bob_, she is granting him access to activities attached to other ties
+#               from _Alice_ to the rest of her _public_ contacts.
+#
+# +weak_star_ties+:: apply the permission to weak and star ties. This is the union of
+#                    the former.
+#            
+#                    Example: group's _admin relation has the permission
+#                    <tt>destroy activity weak_star_ties</tt>
+#                    This means that _admins_ can destroy activities from other
+#                    _members_, _acquaintances_ and _public_.
+#
+class Permission < ActiveRecord::Base
+  has_many :relation_permissions, :dependent => :destroy
+  has_many :relations, :through => :relation_permissions
+
+  %w(represent follow).each do |p|
+    scope p, where(:action => p) # scope :represent, where(:action => 'represent')
+  end
+
+  # The SQL and ARel conditions for permission queries
+  ParameterConditions = {
+    :table => {
+      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.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.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 => {
+      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(
+          as[:relation_id].eq(t.relation_id))
+      },
+      'weak_ties' => lambda { |as, t|
+        # The same sender and receiver, but a stronger or equal relation
+        as[:sender_id].eq(t.sender_id).and(
+          as[:receiver_id].eq(t.receiver_id)).and(
+          as[:relation_id].in(t.relation.stronger_or_equal.map(&:id)))
+      },
+      'star_ties' => lambda { |as, t|
+        # The same receiver and relation
+        as[:sender_id].eq(t.sender_id).and(
+          as[:relation_id].eq(t.relation_id))
+      },
+      'weak_star_ties' => lambda { |as, t|
+        # The same receiver with stronger or equal relations
+        as[:sender_id].eq(t.sender_id).and(
+          as[:relation_id].in(t.relation.stronger_or_equal.map(&:id)))
+      }
+    }
+  }
+
+  class << self
+    # Builds SQL conditions based on {ParameterConditions}
+    def parameter_conditions(tie = nil)
+      if tie.present?
+        ParameterConditions[:arel].inject([]) { |conditions, h|
+          # Add the condition 'permissions.function = key'
+          # to all arel ParameterConditions
+          conditions <<
+            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)
+        }
+      else
+        ParameterConditions[:table].inject([]){ |result, pc|
+          result <<
+            "#{ pc.last } AND #{ sanitize_sql('permissions.function' => pc.first) }"
+        }.join(" OR ")
+      end
+    end
+  end
+
+  # An explanation of the permissions. Type can be brief or detailed.
+  # If detailed, description includes details about the relation
+  def description(type, relation = nil)
+    options = ( relation.present? ? description_options(relation) : {} )
+
+    I18n.t "permission.description.#{ type }.#{ action }.#{ object || "nil" }.#{ function || "nil" }",
+           options
+  end
+
+  private
+
+  def description_options(relation)
+    { 
+      :sphere => relation.sphere.name,
+      :public => I18n.t('relation_public.name')
+    }.tap do |h|
+      case function
+      when NilClass, "star_ties"
+        h[:relation] = relation.name
+      when "weak_ties", "weak_star_ties"
+        h[:relations] = relation.
+                        weaker_or_equal.
+                        sort.
+                        map(&:name).
+                        join(", ")
+
+      end
+    end
+
+  end
+end

data/app/models/post.rb

@@ -0,0 +1,3 @@
+class Post < ActiveRecord::Base
+  validates_presence_of :text
+end

data/app/models/profile.rb

@@ -0,0 +1,53 @@
+class Profile < ActiveRecord::Base
+  belongs_to :actor
+    
+  accepts_nested_attributes_for :actor
+  
+  validates_presence_of :actor_id
+  
+  validates_format_of :mobile, :phone, :fax,
+                      :allow_nil  => true,
+                      :with       => /(^$)|(((\((\+?)\d+\))?|(\+\d+)?)[ ]*-?(\d+[ ]*\-?[ ]*\d*)+$)/,
+                      :message    => "has a invalid format"
+  
+  validates_format_of :website,
+                      :allow_nil  => true,
+                      :with       => /(^$)|((https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$)/ ,
+                      :message    => "has a invalid format"
+  
+  validate :validate_birthday
+  
+  def birthday=(value)    
+    if value.blank?
+      @birthday_formatted_invalid = false    
+      super value
+    else
+      begin
+        super Date.parse(value)
+        @birthday_formatted_invalid = false
+      rescue 
+        @birthday_formatted_invalid = true
+      end
+    end
+  end
+  
+  def age
+    return nil if self.birthday.blank? 
+    now = Time.now.utc.to_date
+    now.year - self.birthday.year - (self.birthday.to_date.change(:year => now.year) > now ? 1 : 0)
+  end
+  
+  # The subject of this profile
+  def subject
+    actor.try(:subject)
+  end
+  
+  private
+
+  def validate_birthday
+    errors.add(:birthday, "is invalid. Please, use \"month/day/year\" format and make sure you choose a valid date" ) if (@birthday_formatted_invalid) || (birthday.present? && !birthday.blank? && birthday > Date.today)
+  end
+
+  
+  
+end

data/app/models/relation/custom.rb

@@ -0,0 +1,122 @@
+# 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
+  validates_uniqueness_of :name, :scope => :sphere_id
+
+  before_validation :assign_parent, :on => :create
+  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']])
+      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
+
+  # Before create callback
+  #
+  # Assign the last relation as parent if there are other custom relations in the sphere
+  def assign_parent
+    return if parent.present? || sphere.customs.blank?
+
+    self.parent = sphere.customs.sort.last
+  end
+
+  # 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

@@ -0,0 +1,83 @@
+# A relation defines a type of {Tie tie}. Relations are 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.
+#
+# = Strength hierarchies
+#
+# Relations are arranged in strength hierarchies, denoting that some ties between
+# two actors are stronger than others. For example, a "friend" relation is stronger than 
+# an "acquaintance" relation.
+#
+# When a strong tie is established, ties with weaker relations are establised as well
+#
+# = Permissions
+#
+# {SocialStream::Models::Subject Subjects} assign {Permission permissions} to 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.
+#
+class Relation < ActiveRecord::Base
+  scope :mode, lambda { |st, rt|
+    where(:sender_type => st, :receiver_type => rt)
+  }
+
+  has_many :relation_permissions, :dependent => :destroy
+  has_many :permissions, :through => :relation_permissions
+
+  has_many :ties, :dependent => :destroy
+
+  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.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
+  end
+
+  # Relation class scoped in the same mode that this relation
+  def mode
+    Relation.mode(sender_type, receiver_type)
+  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_permission.rb

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

data/app/models/sphere.rb

@@ -0,0 +1,9 @@
+class Sphere < ActiveRecord::Base
+  belongs_to :actor
+  
+  has_many :customs, :class_name => "Relation::Custom"
+
+  validates_presence_of :name
+  validates_uniqueness_of :name, :scope => :actor_id
+
+end