vkhater-social_stream-base 0.11.2

data/lib/social_stream/migrations/base.rb

@@ -0,0 +1,58 @@
+module SocialStream
+  module Migrations
+    class Base
+      def initialize
+        require_old_migration 'acts-as-taggable-on', 'lib/generators/acts_as_taggable_on/migration/templates/active_record/migration'
+        @mailboxer_migration = find_migration 'mailboxer'
+        @base_migration = find_migration 'social_stream-base'
+      end
+
+      def up
+        ActsAsTaggableOnMigration.up
+
+        ActiveRecord::Migrator.migrate @mailboxer_migration
+
+        # Run any available migration
+        ActiveRecord::Migrator.migrate @base_migration
+      end
+
+      def down
+        begin
+          ActiveRecord::Migrator.migrate @base_migration, 0
+        rescue
+          puts "WARNING: Social Stream Base failed to rollback"
+        end
+
+        begin
+          ActiveRecord::Migrator.migrate @mailboxer_migration, 0
+        rescue
+          puts "WARNING: Mailboxer migration failed to rollback"
+        end
+
+        begin
+          ActsAsTaggableOnMigration.down
+        rescue
+          puts "WARNING: ActsAsTaggableOnMigration failed to rollback"
+        end
+      end
+
+      protected
+
+      def find_migration(gem)
+        File.join([get_full_gem_path(gem)], 'db/migrate')
+      end
+
+      def require_old_migration(gem,file_path)
+        require File.join([get_full_gem_path(gem),file_path])
+      end
+
+      def get_full_gem_path(gem)
+        if (Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0'))
+          return Gem::Specification.find_by_name(gem).full_gem_path
+        else
+          return Gem::GemPathSearcher.new.find(gem).full_gem_path
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/migrations/components.rb

@@ -0,0 +1,19 @@
+require 'social_stream/migrations/base'
+
+module SocialStream
+  module Migrations
+    class Components < Base
+      def initialize
+        @component = find_migration "social_stream-#{ self.class.name.split('::').last.underscore }"
+      end
+
+      def up(options = {})
+        ActiveRecord::Migrator.migrate @component
+      end
+
+      def down(options = {})
+        ActiveRecord::Migrator.migrate @component, 0
+      end
+    end
+  end
+end

data/lib/social_stream/models/object.rb

@@ -0,0 +1,133 @@
+require 'active_support/concern'
+
+module SocialStream
+  module Models
+    # Additional features for models that are Activity Objects
+    module Object
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer   :_relation_ids
+        attr_accessor :_activity_parent_id
+
+        belongs_to :activity_object,
+                   :validate  => true,
+                   :autosave => true,
+                   :dependent => :destroy
+
+        has_many   :activity_object_activities, :through => :activity_object
+
+#        before_create :create_activity_object_with_type
+
+        unless self == Actor
+          validates_presence_of :author_id, :owner_id, :user_author_id
+
+          after_create :create_post_activity
+          after_update :create_update_activity
+        end
+      end
+
+      module InstanceMethods
+        def activity_object!
+          activity_object || build_activity_object(:object_type => self.class.to_s)
+        end
+
+        # Delegate missing methods to {ActivityObject}, if they exist there
+        def method_missing(method, *args, &block)
+          super
+        rescue NameError => object_error 
+          # These methods must be raised to avoid loops (the :activity_object association calls here again)
+          exceptions = [ :_activity_object_id ]
+          raise object_error if exceptions.include?(method)
+
+          activity_object!.__send__ method, *args, &block
+        end
+
+        # {ActivityObject} handles some methods
+        def respond_to? *args
+          super || activity_object!.respond_to?(*args)
+        end
+
+        # Was the author represented with this {SocialStream::Models::Object object} was created?
+        def represented_author?
+          author_id == user_author_id
+        end
+
+        # All the activities with this object
+        def activities
+          Activity.
+            includes(:activity_objects => self.class.to_s.underscore).
+            where("#{ self.class.quoted_table_name }.id" => self.id)
+        end
+
+        # Build the post activity when this object is not saved
+        def build_post_activity
+          Activity.new :contact_id   => _contact_id,
+                       :relation_ids => Array(_relation_ids)
+        end
+
+	# before_create callback
+	#
+        # Build corresponding ActivityObject including this class type
+        def create_activity_object_with_type #:nodoc:
+          o = create_activity_object! :object_type => self.class.to_s
+	  # WEIRD: Rails 3.1.0.rc3 does not assign activity_object_id
+	  self.activity_object_id = o.id
+        end
+
+        def _contact
+          @_contact ||= author && owner && author.contact_to!(owner)
+        end
+
+        def _contact_id
+          _contact.try(:id)
+        end
+
+        def _relation_ids
+          @_relation_ids ||=
+            if _contact_id.nil?
+              nil
+            else
+              # FIXME: repeated in Activity#fill_relations
+              if _contact.reflexive?
+                _contact.sender.relation_customs.map(&:id)
+              else
+                 _contact.
+                   receiver.
+                   relation_customs.
+                   allow(_contact.sender, 'create', 'activity').
+                   map(&:id)
+              end
+            end
+        end
+
+        def _activity_parent
+          @_activity_parent ||= Activity.find(_activity_parent_id)
+        end
+
+        private
+
+        def create_post_activity
+          create_activity "post"
+        end
+
+        def create_update_activity
+          return if _contact_id.blank?
+          
+          create_activity "update"
+        end
+
+        def create_activity(verb)
+          a = Activity.new :verb         => verb,
+                           :contact      => _contact,
+                           :relation_ids => _relation_ids,
+                           :parent_id    => _activity_parent_id
+
+          a.activity_objects << activity_object
+
+          a.save!
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/models/subject.rb

@@ -0,0 +1,118 @@
+require 'active_support/concern'
+
+module SocialStream
+  module Models
+    # {Subject Subjects} are subtypes of {Actor Actors}. {SocialStream Social Stream} provides two
+    # {Subject Subjects}, {User} and {Group}
+    #
+    # Each {Subject} must defined in +config/initializers/social_stream.rb+ in order to be
+    # included in the application.
+    #
+    # = 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/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/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/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/lib/social_stream/test_helpers/controllers.rb

@@ -0,0 +1,122 @@
+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[:author_id] = contact.sender.id
+        model_attributes[:owner_id]  = contact.receiver.id
+        model_attributes[:user_author_id] = contact.sender.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