social_stream 0.4.6 → 0.5.0

data/lib/social_stream/models/subject.rb

@@ -1,114 +0,0 @@
-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
-    # 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
-        
-        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 :search, lambda{ |param|
-          joins(:actor).merge(Actor.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
-        }
-
-      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/lib/social_stream/models/supertype.rb

@@ -1,44 +0,0 @@
-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
-          SocialStream.__send__ @subtypes_name.to_s.tableize # SocialStream.subjects # in Actor
-        end
-
-        def load_subtype_features
-          features = "SocialStream::Models::#{ @subtypes_name.to_s.classify }".constantize
-
-          subtypes.each do |s|
-            s = s.to_s.classify.constantize
-            s.__send__(:include, features) unless s.ancestors.include?(features)
-          end
-        end
-      end 
-
-      module InstanceMethods
-        def subtype_instance
-          self.class.subtypes.each do |s|
-            i = __send__(s)
-            return i if i.present?
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/social_stream/populate.rb

@@ -1,26 +0,0 @@
-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/lib/social_stream/rails.rb

@@ -1,89 +0,0 @@
-# Database foreign keys
-require 'foreigner'
-# jQuery
-require 'jquery-rails'
-# Permalinks:
-require 'stringex'
-# Hierarchical relationships in Activity and Relation:
-require 'ancestry'
-# Messages
-require 'mailboxer'
-# User authentication
-require 'devise'
-# Authorization
-require 'cancan'
-# REST controllers
-require 'inherited_resources'
-# Scopes in controllers
-require 'has_scope'
-# Logo attachments
-require 'paperclip'
-require 'paperclip/social_stream'
-require 'avatars_for_rails'
-# Pagination
-require 'will_paginate'
-# Oauth
-require 'omniauth/oauth'
-# CSS themes
-require 'rails_css_themes'
-#Tags
-require 'acts-as-taggable-on'
-#Files
-#require 'social_stream-files'
-# HTML forms
-require 'formtastic'
-
-module SocialStream
-  class Engine < ::Rails::Engine #:nodoc:
-    config.app_generators.authentication :devise
-    config.app_generators.messages :mailboxer
-    config.app_generators.taggings :acts_as_taggable_on
-
-    config.to_prepare do
-      %w( actor activity_object ).each do |supertype|
-        supertype.classify.constantize.load_subtype_features
-      end
-
-      # https://rails.lighthouseapp.com/projects/8994/tickets/1905-apphelpers-within-plugin-not-being-mixed-in
-      ApplicationController.helper ActivitiesHelper
-      ApplicationController.helper SubjectsHelper
-      ApplicationController.helper LocationHelper
-      ApplicationController.helper ToolbarHelper
-      ApplicationController.helper ProfilesHelper
-      ApplicationController.helper PermissionsHelper
-      ApplicationController.helper NotificationsHelper
-      ApplicationController.helper ContactsHelper
-      
-      ActsAsTaggableOn::TagsHelper
-    end
-
-    initializer "social_stream.inflections" do
-      ActiveSupport::Inflector.inflections do |inflect|
-        inflect.singular /^([Tt]ie)s$/, '\1'
-      end
-    end
-
-    initializer "social_stream.mime_types" do
-      Mime::Type.register 'application/xrd+xml', :xrd
-    end
-
-    initializer "social_stream.controller_helpers" do
-      ActiveSupport.on_load(:action_controller) do
-        include SocialStream::Controllers::Helpers
-      end
-    end
-
-    initializer "social_stream.avatars_for_rails" do
-      AvatarsForRails.setup do |config|
-        config.avatarable_model = :actor
-        config.current_avatarable_object = :current_actor
-        config.avatarable_filters = [:authenticate_user!]
-        config.avatarable_styles = { :representation => "20x20>",
-                                     :contact        => "30x30>",
-                                     :actor          => '35x35>',
-                                     :profile        => '94x94'}
-      end
-    end
-
-  end
-end

data/lib/social_stream/test_helpers.rb

@@ -1,11 +0,0 @@
-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/lib/social_stream/test_helpers/controllers.rb

@@ -1,119 +0,0 @@
-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 tie
-        model_attributes[:_activity_tie_id] = tie.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/lib/tasks/db/populate.rake

@@ -1,194 +0,0 @@
-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')
-      
-      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(false)
-          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'
-      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'
-      
-      9.times do
-        User.create! :name => Forgery::Name.full_name,
-                     :email => Forgery::Internet.email_address,
-                     :password => 'demonstration',
-                     :password_confirmation => 'demonstration'
-      end
-      
-      set_logos(User)
-      
-      users_end = Time.now 
-      puts '   -> ' + (users_end - users_start).round(4).to_s + 's'
-      
-      puts 'Groups population'
-      groups_start = Time.now
-      
-      # = Groups
-      available_actors = Actor.all
-
-      10.times do
-        founder = available_actors[rand(available_actors.size)]
-        
-        Group.create :name  => Forgery::Name.company_name,
-                     :email => Forgery::Internet.email_address,
-        :_founder => founder.slug
-      end
-      
-      set_logos(Group)
-      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
-        
-        Forgery::Basic.number(:at_most => actors.size).times do
-          actor = actors.delete_at((rand * actors.size).to_i)
-          a.sent_ties.create :receiver => actor,
-                             :relation => relations.random
-        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))
-        
-        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)),
-                        :updated_at => updated,
-        :_activity_tie_id => t.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'
-      
-    end
-  end
-end