social_stream 0.4.6 → 0.5.0

data/app/models/authentication.rb

@@ -1,3 +0,0 @@
-class Authentication < ActiveRecord::Base
-  belongs_to :user
-end

data/app/models/comment.rb

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

data/app/models/contact.rb

@@ -1,121 +0,0 @@
-# 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
-
-  def sender_subject
-    sender.subject
-  end
-
-  def receiver_subject
-    receiver.subject
-  end
-
-  def relation_ids
-    @relation_ids ||=
-      sender.ties_to(receiver).map(&:relation_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
-  end
-
-  def to_param
-    id
-  end
-
-  def to_key
-    [id]
-  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
-
-    # TODO: errors
-    true
-  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)
-
-      # 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)
-
-      @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
-
-      create_activity
-      send_message
-    end
-  end
-
-  private
-
-  # Create the related {Activity}
-  def create_activity
-    return if @previous.present?
-
-    @new.each do |t|
-      Activity.create! :_tie => t,
-                       :activity_verb => ActivityVerb[verb]
-    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
-end

data/app/models/group.rb

@@ -1,49 +0,0 @@
-class Group < ActiveRecord::Base
-  attr_accessor :_founder
-  attr_accessor :_participants
-
-  delegate :description, :description=, :to => :profile!
-
-  after_create :create_founder
-  after_create :create_participants
-
-  def profile!
-    actor!.profile || actor!.build_profile
-  end
-
-  def followers
-    contacts(:subject_type => :user, :direction => :received)
-  end
-  
-  def recent_groups
-    contacts(:type => :group, :direction => :sent) do |q|
-      q.select("ties.created_at").
-        merge(Tie.recent)
-    end
-  end
- 
-  private
-
-  #Creates the ties between the group and the founder
-  def create_founder
-    founder =
-      Actor.find_by_slug(_founder) || raise("Cannot create group without founder")
-
-    sent_ties.create! :receiver => founder,
-                      :relation => relation_customs.sort.first
-  end
-  
-  #Creates the ties betwbeen the group and the participants
-  def create_participants
-    
-     return if @_participants.blank?
-    
-     @_participants.each do |participant|
-      
-      participant_actor = Actor.find_by_slug!(participant)
-
-      sent_ties.create! :receiver => participant_actor,
-                        :relation => relation_customs.sort.first
-     end
-  end
-end

data/app/models/like.rb

@@ -1,49 +0,0 @@
-# Convenience class for managing like activities
-class Like
-  attr_reader :object
-
-  class << self
-    # Find the children activity of activity_id liked by subject
-    def find(subject, object)
-      like = new(object.liked_by(subject).first)
-      # Cache object to make it available before it is destroyed
-      like.object
-      like
-    end
-
-    # Like #find but raises error if not found
-    def find!(subject, object)
-      find(subject, object) ||
-        raise(ActiveRecord::RecordNotFound)
-    end
-
-    def build(subject, object)
-       new object.new_like(subject)
-    end
-  end
-
-  # Initialize a new like activity
-  def initialize(activity)
-    @like = activity
-  end
-
-  def save
-    @like.save
-  end
-  
-  # The object that is liked. It can be an activity
-  def object
-    @object ||=
-      if @like.is_root?
-        obj = @like.direct_object
-        obj = obj.subject if obj.is_a?(Actor)
-        obj
-      else
-        @like.parent
-      end
-  end
-  
-  def destroy
-    @like.destroy
-  end
-end

data/app/models/permission.rb

@@ -1,180 +0,0 @@
-# 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

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

data/app/models/profile.rb

@@ -1,53 +0,0 @@
-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