social_stream 0.9.1 → 0.9.2

data/base/lib/social_stream/models/subject.rb

@@ -0,0 +1,122 @@
+require 'active_support/concern'
+
+module SocialStream
+  module Models
+    # {Subject Subjects} are subtypes of {Actor}. {SocialStream} provides two
+    # {Subject Subjects}, {User} and {Group}
+    #
+    # Each {Subject} is defined in +config/initializers/social_stream.rb+
+    #
+    # This module provides additional features for models that are subjects,
+    # extending them. Including the module in each {Subject} model is not required!
+    # After declared in +config/initializers/social_stream.rb+, {SocialStream} is
+    # responsible for adding subject features to each model.
+    #
+    # = Scopes
+    # There are several scopes available for subjects 
+    #
+    # alphabetic:: sort subjects by name
+    # name_search:: simple search by name
+    # distinct_initials:: get only the first letter of the name
+    # followed:: sort by most following incoming {Tie ties}
+    # liked:: sort by most likes
+    #
+    module Subject
+      extend ActiveSupport::Concern
+      
+      included do
+        belongs_to :actor,
+                   :validate => true,
+                   :autosave => true,
+                   :dependent => :destroy
+        
+        has_one :profile, :through => :actor
+        
+        validates_presence_of :name
+        
+        accepts_nested_attributes_for :profile
+        
+        scope :alphabetic, joins(:actor).merge(Actor.alphabetic)
+
+        scope :letter, lambda{ |param|
+          joins(:actor).merge(Actor.letter(param))
+        }
+
+        scope :name_search, lambda{ |param|
+          joins(:actor).merge(Actor.name_search(param))
+        }
+        
+        scope :tagged_with, lambda { |param|
+          if param.present?
+            joins(:actor => :activity_object).merge(ActivityObject.tagged_with(param))
+          end
+        }
+
+        scope :distinct_initials, joins(:actor).merge(Actor.distinct_initials)
+
+        scope :followed, lambda { 
+          joins(:actor).
+            order("actors.follower_count DESC")
+        }
+
+        scope :liked, lambda { 
+          joins(:actor => :activity_object).
+            order('activity_objects.like_count DESC')
+        }
+
+        scope :most, lambda { |m|
+          types = %w( followed liked )
+
+          if types.include?(m)
+            __send__ m
+          end
+        }
+  
+        define_index do
+          indexes actor.name, :sortable => true
+          indexes actor.email
+          indexes actor.slug
+                
+          has created_at
+        end
+      end
+      
+      module InstanceMethods
+        def actor!
+          actor || build_actor(:subject_type => self.class.to_s)
+        end
+        
+        def to_param
+          slug
+        end
+
+        # Delegate missing methods to {Actor}, if they exist there
+        def method_missing(method, *args, &block)
+          super
+        rescue NameError => subject_error 
+          # These methods must be raised to avoid loops (the :actor association calls here again)
+          exceptions = [ :_actor_id ]
+          raise subject_error if exceptions.include?(method)
+
+          actor!.__send__ method, *args, &block
+        end
+
+        # {Actor} handles some methods
+        def respond_to? *args
+          super || actor!.respond_to?(*args)
+        end
+      end
+      
+      module ClassMethods
+        def find_by_slug(perm)
+          includes(:actor).where('actors.slug' => perm).first
+        end
+        
+        def find_by_slug!(perm)
+          find_by_slug(perm) ||
+            raise(ActiveRecord::RecordNotFound)
+        end 
+      end
+    end
+  end
+end

data/base/lib/social_stream/models/supertype.rb

@@ -0,0 +1,37 @@
+require 'active_support/concern'
+
+module SocialStream #:nodoc:
+  module Models
+    # Common methods for models that have subtypes. Currently, there are two supertypes:
+    # * Actor: participates in the social network and has ties with other actors. Its subtypes are subjects, like user or group
+    # * ActivityObject: created and managed by actors in activities. Its subtypes are objects, like post or comment
+    module Supertype
+      extend ActiveSupport::Concern
+
+      included do
+        subtypes.each do |s|
+          has_one s, :dependent => :destroy
+        end
+      end
+
+      module ClassMethods
+        def subtypes_name
+          @subtypes_name
+        end
+
+        def subtypes
+          SocialStream.__send__ subtypes_name.to_s.tableize # SocialStream.subjects # in Actor
+        end
+      end 
+
+      module InstanceMethods
+        def subtype_instance
+          if __send__("#{ self.class.subtypes_name }_type").present?      # if object_type.present?
+            object_class = __send__("#{ self.class.subtypes_name }_type") #   object_class = object_type # => "Video"
+            __send__ object_class.constantize.base_class.to_s.underscore  #   __send__ "document"
+                       end                                                # end
+        end
+      end
+    end
+  end
+end

data/base/lib/social_stream/populate.rb

@@ -0,0 +1,26 @@
+module SocialStream
+  module Populate
+
+    class << self
+      # Yields each element of array y times given by 
+      # {power law distribution}[http://en.wikipedia.org/wiki/Power_law]
+      # y = ax**k + e
+      # 
+      # Options: Each constant in the function
+      #
+      def power_law(array, options = {})
+        options[:a] ||= array.size
+        options[:k] ||= -2.5
+        options[:e] ||= 1
+
+        array.each do |i|
+          value = options[:a] * (array.index(i) + 1) ** options[:k] + options[:e]
+
+          value.round.times do
+            yield i
+          end
+        end
+      end
+    end
+  end
+end

data/base/lib/social_stream/test_helpers.rb

@@ -0,0 +1,11 @@
+module SocialStream
+  module TestHelpers
+    # Represent this subject
+    def represent(subject)
+      session[:subject_type] = subject.class.to_s
+      session[:subject_id] = subject.id
+
+      subject
+    end
+  end
+end

data/base/lib/social_stream/test_helpers/controllers.rb

@@ -0,0 +1,120 @@
+module SocialStream
+  module TestHelpers
+    module Controllers
+      # Post for PostsController
+      def model_class
+        @model_class ||=
+          described_class.to_s.sub!("Controller", "").singularize.constantize
+      end
+
+      # :post for PostsController
+      def model_sym
+        @model_sym ||=
+          model_class.to_s.underscore.to_sym
+      end
+
+      # Factory.attributes_for(:post) for PostsController
+      def model_attributes
+        @model_attributes ||=
+          Factory.attributes_for(model_sym)
+      end
+
+      def attributes
+        { model_sym => model_attributes }
+      end
+
+      def updating_attributes
+        attributes.merge({ :id => @current_model.to_param })
+      end
+
+      # Post.count
+      def model_count
+        model_class.count
+      end
+
+      def model_assigned_to contact, relation_ids
+        model_attributes[:_contact_id] = contact.id
+        model_attributes[:_relation_ids] = Array(relation_ids).map(&:id)
+      end
+
+      shared_examples_for "Allow Creating" do
+        it "should create" do
+          count = model_count
+          post :create, attributes
+
+          resource = assigns(model_sym)
+
+          model_count.should eq(count + 1)
+          resource.should be_valid
+          response.should redirect_to(resource)
+        end
+      end
+
+      shared_examples_for "Deny Creating" do
+        it "should not create" do
+          count = model_count
+          begin
+            post :create, attributes
+          rescue CanCan::AccessDenied
+          end
+
+          resource = assigns(model_sym)
+
+          model_count.should eq(count)
+          resource.should be_new_record
+        end
+      end
+
+      shared_examples_for "Allow Updating" do
+        it "should update" do
+          put :update, updating_attributes
+
+          resource = assigns(model_sym)
+
+          resource.should_receive(:update_attributes).with(attributes)
+          assert resource.valid?
+          response.should redirect_to(resource)
+        end
+      end
+
+      shared_examples_for "Deny Updating" do
+        it "should not update" do
+          begin
+            put :update, updating_attributes
+          rescue CanCan::AccessDenied
+          end
+
+          resource = assigns(model_sym)
+
+          resource.should_not_receive(:update_attributes)
+        end
+      end
+
+      shared_examples_for "Allow Destroying" do
+        it "should destroy" do
+          count = model_count
+          delete :destroy, :id => @current_model.to_param
+
+          resource = assigns(model_sym)
+
+          model_count.should eq(count - 1)
+        end
+      end
+
+      shared_examples_for "Deny Destroying" do
+        it "should not destroy" do
+          count = model_count
+          begin
+            delete :destroy, :id => @current_model.to_param
+          rescue CanCan::AccessDenied
+          end
+
+          resource = assigns(model_sym)
+
+          model_count.should eq(count)
+        end
+      end
+
+    end
+  end
+end

data/base/lib/social_stream/toolbar_config.rb

@@ -0,0 +1,99 @@
+module SocialStream
+  module ToolbarConfig
+    #Prints the default home toolbar menu
+    def default_home_toolbar_menu
+      items = Array.new
+
+      #Messages
+      items << {:key => :messages,
+        :name => image_tag("btn/new.png")+t('message.other')+' (' + current_subject.mailbox.inbox(:unread => true).count.to_s + ')',
+        :url => "#",
+        :options => {:link => {:id => "messages_menu"}},
+        :items => [
+          {:key => :message_new, :name => image_tag("btn/message_new.png")+ t('message.new'), :url => new_message_path, :options => {:link =>{:remote=> false}}},
+          {:key => :message_inbox, :name => image_tag("btn/message_inbox.png")+t('message.inbox')+' (' + current_subject.mailbox.inbox(:unread => true).count.to_s + ')',
+            :url => conversations_path, :options => {:link =>{:remote=> false}}},
+          {:key => :message_sentbox, :name => image_tag("btn/message_sentbox.png")+t('message.sentbox'), :url => conversations_path(:box => :sentbox), :options => {:link =>{:remote=> false}}},
+          {:key => :message_trash, :name => image_tag("btn/message_trash.png")+t('message.trash'), :url => conversations_path(:box => :trash)}
+        ]}
+
+      #Documents if present
+      if SocialStream.activity_forms.include? :document
+        items << {:key => :resources,
+          :name => image_tag("btn/btn_resource.png",:class =>"menu_icon")+t('resource.mine'),
+          :url => "#",
+          :options => {:link => {:id => "resources_menu"}},
+          :items => [
+            {:key => :resources_documents,:name => image_tag("btn/btn_document.png")+t('document.title'),:url => documents_path},
+            {:key => :resources_pictures,:name => image_tag("btn/btn_gallery.png")+t('picture.title'),:url => pictures_path},
+            {:key => :resources_videos,:name => image_tag("btn/btn_video.png")+t('video.title'),:url => videos_path},
+            {:key => :resources_audios,:name => image_tag("btn/btn_audio.png")+t('audio.title'),:url => audios_path}
+          ]}
+      end
+
+      #Contacts
+      items << {:key => :contacts,
+        :name => image_tag("btn/btn_friend.png")+t('contact.other'),
+        :url => "#",
+        :options => {:link => {:id => "contacts_menu"}},
+        :items => [
+          {:key => :invitations, :name => image_tag("btn/btn_friend.png")+t('contact.current'), :url => contacts_path},
+          {:key => :contacts_graph, :name => image_tag("btn/btn_friend.png")+t('contact.graph.one'), :url => ties_path},
+          {:key => :invitations, :name => image_tag("btn/btn_friend.png")+t('contact.pending.other'), :url => contacts_path(:pending=>true)},
+          {:key => :invitations, :name => image_tag("btn/btn_invitation.png")+t('invitation.toolbar'), :url => new_invitation_path}
+        ]}
+
+      render_items items
+    end
+
+    #Prints the default profile toolbar menu
+    def default_profile_toolbar_menu(subject = current_subject)
+      items = Array.new
+      #Information button
+      items << {:key => :subject_info,
+        :name => image_tag("btn/btn_edit.png")+t('menu.information'),
+        :url => [subject, :profile]
+      }
+
+      if subject!=current_subject
+        #Like button
+        items << {:key => :like_button,
+          :name => link_like_params(subject)[0],
+          :url => link_like_params(subject)[1],
+          :options => {:link => link_like_params(subject)[2]}}
+
+        if user_signed_in?
+          #Relation button
+          items << {:key => :subject_relation,
+            :name => image_tag("btn/btn_friend.png") + current_subject.contact_to!(subject).status,
+            :url => edit_contact_path(current_subject.contact_to!(subject))
+          }
+          #Send message button
+          items << {:key => :send_message,
+            :name => image_tag("btn/btn_send.png")+t('message.send'),
+            :url => new_message_path(:receiver => subject.slug)
+          }
+        end
+      end
+      #Documents if present
+      if SocialStream.activity_forms.include? :document
+        if subject == current_subject
+          resources_label = t('resource.mine')
+        else
+          resources_label = t('resource.title')
+        end
+        items << {:key => :resources,
+          :name => image_tag("btn/btn_resource.png",:class =>"menu_icon")+resources_label,
+          :url => "#",
+          :options => {:link => {:id => "resources_menu"}},
+          :items => [
+            {:key => :resources_documents,:name => image_tag("btn/btn_document.png")+t('document.title'),:url => polymorphic_path([subject, Document.new])},
+            {:key => :resources_pictures,:name => image_tag("btn/btn_gallery.png")+t('picture.title'),:url => polymorphic_path([subject, Picture.new])},
+            {:key => :resources_videos,:name => image_tag("btn/btn_video.png")+t('video.title'),:url => polymorphic_path([subject, Video.new])},
+            {:key => :resources_audios,:name => image_tag("btn/btn_audio.png")+t('audio.title'),:url => polymorphic_path([subject, Audio.new])}
+          ]}
+      end
+      render_items items
+    end
+  end
+end

data/base/lib/tasks/db/populate.rake

@@ -0,0 +1,214 @@
+namespace :db do
+  desc 'Populate database with fake data for development'
+  task :populate => [ 'db:seed', 'db:populate:create' ]
+
+  namespace :populate do
+
+    desc "Reload populate data"
+    task :reload => [ 'db:reset', :create ]
+
+    desc "Create populate data"
+    task :create => :environment do
+
+      LOGOS_PATH = File.join(Rails.root, 'lib', 'logos')
+      USERS = (ENV["USERS"] || 9).to_i
+      GROUPS =  (ENV["GROUPS"] || 10).to_i
+      if ENV["HARDCORE"].present?
+        USERS = 999
+        GROUPS = 1000    
+      end
+      if USERS < 9
+        USERS = 9
+        puts "WARNING: There should be at least 10 users (Demo user and 9 more). Changing USERS to 9."
+      end
+      if GROUPS < 10
+        GROUPS = 10
+        puts "WARNING: There should be at least 10 groups. Changing GROUPS to 10."
+      end
+
+      Mailboxer.setup do |config|
+        config.uses_emails = false
+      end
+
+      def set_logos(klass)
+        klass.all.each do |i|
+          logo = Dir[File.join(LOGOS_PATH, klass.to_s.tableize, "#{ i.id }.*")].first
+          avatar = Dir[File.join(LOGOS_PATH, klass.to_s.tableize, "#{ i.id }.*")].first
+
+          if avatar.present? && File.exists?(avatar)
+            Avatar.copy_to_temp_file(avatar)
+            dimensions = Avatar.get_image_dimensions(avatar)
+            l = Avatar.new(:actor => i.actor,:logo => File.open(avatar), :name => File.basename(avatar), :crop_x => 0, :crop_y => 0, :crop_w => dimensions[:width], :crop_h => dimensions[:height] )
+            l.active = true
+            l.save
+          end
+        end
+      end
+
+      def set_tags(klass)
+        klass.all.each do |el|
+          el.tag_list = Forgery::LoremIpsum.words(1,:random => true)+", "+
+                        Forgery::LoremIpsum.words(1,:random => true)+", "+
+                        Forgery::LoremIpsum.words(1,:random => true)
+          el.save!
+        end
+      end
+
+      puts 'User population (Demo and ' + USERS.to_s + ' users more)'
+      users_start = Time.now
+
+      # = Users
+
+      # Create demo user if not present
+      if User.find_by_name('demo').blank?
+        User.create! :name => 'Demo',
+                     :email => 'demo@social-stream.dit.upm.es',
+                     :password => 'demonstration',
+                     :password_confirmation => 'demonstration'
+      end
+
+      require 'forgery'
+
+      USERS.times do
+        User.create! :name => Forgery::Name.full_name,
+                     :email => Forgery::Internet.email_address,
+                     :password => 'demonstration',
+                     :password_confirmation => 'demonstration'
+      end
+
+
+      users_end = Time.now
+      puts '   -> ' + (users_end - users_start).round(4).to_s + 's'
+
+      puts 'Groups population (' + GROUPS.to_s + ' groups)'
+      groups_start = Time.now
+
+      # = Groups
+      available_actors = Actor.all
+
+      GROUPS.times do
+        founder = available_actors[rand(available_actors.size)]
+
+        Group.create! :name  => Forgery::Name.company_name,
+                      :email => Forgery::Internet.email_address,
+                      :_contact_id => founder.ego_contact.id
+      end
+
+      set_tags(Group)
+
+      groups_end = Time.now
+      puts '   -> ' +  (groups_end - groups_start).round(4).to_s + 's'
+
+
+      puts 'Ties population'
+      ties_start = Time.now
+
+      # Reload actors to include groups
+      available_actors = Actor.all
+
+      # = Ties
+      available_actors.each do |a|
+        actors = available_actors.dup - Array(a)
+        relations = a.relations
+        break if actors.size==0
+        Forgery::Basic.number(:at_most => actors.size).times do
+          actor = actors.delete_at((rand * actors.size).to_i)
+          a.contact_to!(actor).relation_ids = Array(Forgery::Extensions::Array.new(relations).random.id)
+        end
+      end
+
+      ties_end = Time.now
+      puts '   -> ' +  (ties_end - ties_start).round(4).to_s + 's'
+
+      # = Posts
+
+      puts 'Post population'
+      posts_start = Time.now
+
+      SocialStream::Populate.power_law(Tie.all) do |t|
+        updated = Time.at(rand(Time.now.to_i))
+
+        p = Post.create :text =>
+                      "This post should be for #{ t.relation.name } of #{ t.sender.name }.\n#{ Forgery::LoremIpsum.paragraph(:random => true) }",
+                        :created_at => Time.at(rand(updated.to_i)),
+                        :updated_at => updated,
+                        :_contact_id => t.contact_id,
+                        :_relation_ids => Array(t.relation_id)
+
+        p.post_activity.update_attributes(:created_at => p.created_at,
+                                          :updated_at => p.updated_at)
+      end
+
+      posts_end = Time.now
+      puts '   -> ' +  (posts_end - posts_start).round(4).to_s + 's'
+
+      puts 'Mailboxer population'
+      mailboxer_start = Time.now
+
+      # = Mailboxer
+      available_actors = Actor.all
+
+      available_actors.each do |a|
+        actors = available_actors.dup - Array(a)
+
+        mult_recp = actors.uniq
+        if (demo = User.find_by_name('demo')) and !mult_recp.include? Actor.normalize(demo)
+          mult_recp << Actor.normalize(demo)
+        end
+        actor = mult_recp[(rand * mult_recp.size).to_i]
+        mult_recp.delete(actor)
+        mail = actor.send_message(mult_recp, "Hello all, I am #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}", Forgery::LoremIpsum.words(10,:random => true))
+        actor = mult_recp[(rand * mult_recp.size).to_i]
+        mail = actor.reply_to_all(mail, "Well, I am #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+        actor = mult_recp[(rand * mult_recp.size).to_i]
+        mail = actor.reply_to_all(mail, "Ok, I am #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+        actor = mult_recp[(rand * mult_recp.size).to_i]
+        mail = actor.reply_to_all(mail, "Pretty well, I am #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+        actor = mult_recp[(rand * mult_recp.size).to_i]
+        actor.reply_to_all(mail, "Finally, I am #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+
+
+        if (demo = User.find_by_name('demo'))
+          next if Actor.normalize(demo)==Actor.normalize(a)
+          mail = a.send_message(demo, "Hello, #{demo.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}", Forgery::LoremIpsum.words(10,:random => true))
+          if rand > 0.5
+            mail = demo.reply_to_sender(mail, "Pretty well #{a.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+            if rand > 0.5
+              a.reply_to_sender(mail, "Ok #{demo.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+            end
+          end
+          if rand > 0.75
+            mail.conversation.move_to_trash(demo)
+          end
+        end
+
+        Forgery::Basic.number(:at_most => actors.size).times do
+          actor = actors.delete_at((rand * actors.size).to_i)
+          next if Actor.normalize(actor)==Actor.normalize(a)
+          mail = a.send_message(actor, "Hello, #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}", Forgery::LoremIpsum.words(10,:random => true))
+          if rand > 0.5
+            mail = actor.reply_to_sender(mail, "Pretty well #{a.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+            if rand > 0.5
+              a.reply_to_sender(mail, "Ok #{actor.name}. #{Forgery::LoremIpsum.sentences(2,:random => true)}")
+            end
+          end
+          if rand > 0.75
+            mail.conversation.move_to_trash(actor)
+          end
+        end
+      end
+
+      mailboxer_end = Time.now
+      puts '   -> ' +  (mailboxer_end - mailboxer_start).round(4).to_s + 's'
+
+
+
+      puts 'Avatar population'
+      avatar_start = Time.now
+      SocialStream.subjects.each {|a| set_logos(Kernel.const_get(a.to_s.classify)) }
+      avatar_end = Time.now
+      puts '   -> ' +  (avatar_end - avatar_start).round(4).to_s + 's'
+
+    end
+  end
+end