vkhater-social_stream-base 0.11.2

data/lib/social_stream/toolbar_config/base.rb

@@ -0,0 +1,94 @@
+module SocialStream
+  module ToolbarConfig
+    module Base
+      # Base toolbar items
+      def home_toolbar_items
+        Array.new.tap do |items|
+          #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 => pending_contacts_path},
+              {:key => :invitations, :name => image_tag("btn/btn_invitation.png")+t('invitation.toolbar'), :url => new_invitation_path}
+            ]
+          }
+
+          # Groups
+          items << {
+            :key  => :groups,
+            :name => image_tag("btn/btn_group.png") + t('group.other'),
+            :url  => '#',
+            :options => { :link => { :id => "groups_menu" } },
+            :items => [
+              {:key => :new_group ,:name => image_tag("btn/btn_group.png")+t('group.new.action'),:url => new_group_path}
+            ]
+          }
+        end
+      end
+
+      # Builds the default profile toolbar items
+      def profile_toolbar_items(subject = current_subject)
+        Array.new.tap do |items|
+        #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
+        end
+      end
+
+      def messages_toolbar_items
+        Array.new.tap do |items|
+        # Messages
+          items << { :key => :message_new,
+            :name => image_tag("btn/message_new.png")+ t('message.new'),
+            :url => new_message_path,
+            :options => {:link =>{:remote=> false}}}
+          items << { :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}}}
+          items << { :key => :message_sentbox,
+            :name => image_tag("btn/message_sentbox.png")+t('message.sentbox'),
+            :url => conversations_path(:box => :sentbox),
+            :options => {:link =>{:remote=> false}}}
+          items << { :key => :message_trash,
+            :name => image_tag("btn/message_trash.png")+t('message.trash'),
+            :url => conversations_path(:box => :trash)}
+        end
+      end
+    end
+  end
+end
+

data/lib/social_stream/views/list.rb

@@ -0,0 +1,17 @@
+module SocialStream
+  module Views
+    class List < Array
+      def insert_before key, obj
+        position = index{ |i| i[:key] == key }
+
+        insert position, obj
+      end
+
+      def insert_after key, obj
+        position = index{ |i| i[:key] == key } + 1
+
+        insert position, obj
+      end
+    end
+  end
+end

data/lib/social_stream/views/settings/base.rb

@@ -0,0 +1,43 @@
+module SocialStream
+  module Views
+    module Settings
+      module Base
+        def settings_items
+          SocialStream::Views::List.new.tap do |items|
+            if current_subject  == current_user
+              items << {
+                :key  => 'user.edit',
+                :html => render(:partial => "devise/registrations/edit_user",
+                                :locals => {
+                                             :resource => current_user,
+                                             :resource_name => :user
+                                           })
+              }
+            end
+
+            items << {
+              :key  => 'notifications',
+              :html => render(:partial => "notifications")
+            }
+
+            if current_subject.respond_to? :authentication_token
+              items << {
+                :key  => 'api_key',
+                :html => render(:partial => "api_key")
+              }
+            end
+
+            items << {
+              :key  => 'destroy',
+              :html => 
+                current_subject == current_user ?
+                  render(:partial => "devise/registrations/delete_account",
+                                     :locals => { :resource => current_user, :resource_name => :user }) :
+                  render(:partial => 'destroy')
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/views/sidebar/base.rb

@@ -0,0 +1,27 @@
+module SocialStream
+  module Views
+    module Sidebar
+      module Base
+        def sidebar_items type
+          SocialStream::Views::List.new.tap do |items|
+            if type == :group_index
+              items << {
+                :key => 'group.cloud',
+                :html => render(:partial => 'groups/tag_cloud')
+              }
+
+            end
+
+            if user_signed_in?
+              items << {
+                :key => 'suggestions_and_pendings',
+                :html => render(:partial => 'contacts/suggestions_and_pendings')
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/tasks/db/populate.rake

@@ -0,0 +1,241 @@
+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
+      CHEESECAKE = (ENV["CHEESECAKE"].present? || false)
+      if CHEESECAKE
+        puts "Cheesecake Testing mode: ON"
+      end
+      if ENV["HARDCORE"].present?
+        USERS = 999
+        GROUPS = 1000    
+        puts "Hardcore mode: ON (May the Force be with you brave Padawan)"
+        if CHEESECAKE
+          puts "WARNING: Hardcore and Cheesecake Modes activated. This situation is really slow. Please, avoid it."
+        end        
+      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,
+                      :author_id => founder.id,
+                      :user_author_id => founder.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.relation_customs + Array.wrap(a.relation_reject)
+        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) unless a==actor
+        end
+        if CHEESECAKE     
+          actor = Actor.first
+          unless a==actor
+            puts a.name + " connecting with " + actor.name
+            a.contact_to!(actor).relation_ids = Array(Forgery::Extensions::Array.new(relations).random.id)
+          end
+        end
+      end
+
+      ties_end = Time.now
+      puts '   -> ' +  (ties_end - ties_start).round(4).to_s + 's'
+
+      # = Posts
+      puts 'Post population'
+      unless CHEESECAKE
+        posts_start = Time.now
+  
+        SocialStream::Populate.power_law(Tie.all) do |t|
+          updated = Time.at(rand(Time.now.to_i))
+  
+          author = t.sender
+          owner  = t.receiver
+          user_author = ( t.sender.subject_type == "User" ? t.sender : t.sender.user_author )
+  
+          p = Post.create :text =>
+                        "This post sActorhould 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,
+                          :author_id  => author.id,
+                          :owner_id   => owner.id,
+                          :user_author_id => user_author.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'
+      else
+        puts '   -> Cheesecake Testing Mode. Avoiding Post Population.'        
+      end
+
+      # = Mailboxer      
+      puts 'Mailboxer population'
+      unless CHEESECAKE
+        mailboxer_start = Time.now
+        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'
+      else
+        puts '   -> Cheesecake Testing Mode. Avoiding Mailboxer Population.'        
+      end
+
+
+      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

data/lib/tasks/workers.rake

@@ -0,0 +1,163 @@
+# Rake task to launch multiple Resque workers in development/production with simple management included
+
+require 'resque/tasks'    # Require Resque tasks
+
+namespace :workers do
+
+  # = $ rake workers:start
+  #
+  # Launch multiple Resque workers with the Rails environment loaded,
+  # so they have access to your models, etc.
+  #
+  # Each worker is being run in their own separate process (_not_ thread).
+  #
+  # On clean shutdown (SIGINT / Ctrl-C, SIGQUIT, SIGTERM), the task will clean
+  # after itself: kill its workers and delete PID files, when appropriate. It
+  # will deal fine with already dead workers.
+  #
+  #
+  # Default options like COUNT can and should be over-ridden when invoking, of course:
+  #
+  #    $ rake workers:start COUNT=10 QUEUE=my_queue
+  #
+  #
+  # To daemonize, simply run with nohup:
+  #
+  #    $ nohup rake workers:start > log/workers.log 2>&1 &
+  #
+  #
+  # You can and should set up your monitoring tool to watch for process with PID
+  # from `cat tmp/pids/resque/master.pid`.
+  #
+  # For proper monitoring of _individual_ workers, use provided examples for God or Monit:
+  # http://github.com/defunkt/resque/blob/master/examples/.
+  #
+  #
+  # A task for killing all workers on the machine (`rake workers:killall`) is also provided,
+  # for pruning orphaned workers etc.
+  #
+  desc "Run and manage group of Resque workers with some default options"
+  task :start => :environment do
+
+    # - CONFIGURATION ----
+    ENV['QUEUE']   ||= '*'
+    ENV['COUNT']   ||= '3'
+    # --------------------
+
+    def queue
+      ENV['QUEUE']
+    end
+
+    def count
+      ENV['COUNT']
+    end
+
+    def Process.exists?(pid)
+      kill(0, pid.to_i) rescue false
+    end
+
+    def pid_directory
+      @pid_directory ||= Rails.root.join('tmp', 'pids', "resque")
+    end
+
+    def pid_directory_for_group
+      @pid_directory_for_group ||= Rails.root.join('tmp', 'pids', "resque", queue)
+    end
+
+    def group_master_pid
+      File.read pid_directory.join("#{queue}.pid").to_s rescue nil
+    end
+
+    def group?
+      !group_master_pid || group_master_pid.to_s == Process.pid.to_s
+    end
+
+    def group_running?
+      Process.exists?(group_master_pid)
+    end
+
+    def kill_worker(pid)
+      Process.kill("QUIT", pid)
+      puts "Killed worker with PID #{pid}"
+      rescue Errno::ESRCH => e
+        puts " STALE worker with PID #{pid}"
+    end
+
+    def kill_workers
+      @pids.each { |pid| kill_worker(pid) }
+    end
+
+    def kill_workers_and_remove_pids_for_group
+      Dir.glob(pid_directory_for_group.join('worker_*.pid').to_s) do |pidfile|
+        begin
+          pid = pidfile[/(\d+)\.pid/, 1].to_i
+          kill_worker(pid)
+        ensure
+          FileUtils.rm pidfile, :force => true
+        end
+      end
+      if group_master_pid
+        FileUtils.rm    pid_directory.join("#{queue}.pid").to_s
+        FileUtils.rm_rf pid_directory_for_group.to_s
+      end
+    end
+
+    def shutdown
+      puts "\n*** Exiting"
+      if group?
+        kill_workers_and_remove_pids_for_group
+      else
+        kill_workers
+      end
+      exit(0)
+    end
+
+    # Clean up after dead group from before -- and become one
+    unless group_running?
+      puts "--- Cleaning up after previous group (PID: #{group_master_pid})"
+      kill_workers_and_remove_pids_for_group 
+    end
+
+    # Handle exit
+    trap('INT')  { shutdown }
+    trap('QUIT') { shutdown }
+    trap('TERM') { shutdown }
+    trap('KILL') { shutdown }
+    trap('SIGKILL') { shutdown }
+
+    puts "=== Launching #{ENV['COUNT']} worker(s) on '#{ENV['QUEUE']}' queue(s) with PID #{Process.pid}"
+
+    # Launch workers in separate processes, saving their PIDs
+    @pids = []
+    ENV['COUNT'].to_i.times do
+      @pids << Process.fork { Rake::Task['resque:work'].invoke }
+    end
+
+    if group?
+      # Make sure we have directory for pids
+      FileUtils.mkdir_p pid_directory.to_s
+      FileUtils.mkdir_p pid_directory_for_group.to_s
+      # Create PID files for workers
+      File.open( pid_directory.join("#{queue}.pid").to_s, 'w' ) do |f| f.write Process.pid end
+      @pids.each do |pid|
+        File.open( pid_directory_for_group.join("worker_#{pid}.pid").to_s, 'w' ) { |f| f.write pid }
+      end
+      # Stay in foreground, if any of our workers dies, we'll get killed so Monit/God etc can come to the resq^Hcue
+      Process.wait
+    else
+      # Stay in foreground, if any of our workers dies, continue running
+      Process.waitall
+    end
+  end
+
+  desc "Kill ALL workers on this machine"
+  task :kilall do
+    require 'resque'
+    Resque::Worker.all.each do |worker|
+      puts "Shutting down worker #{worker}"
+      host, pid, queues = worker.id.split(':')
+      Process.kill("QUIT", pid.to_i)
+    end
+  end
+
+end