socialization 0.5.0.beta3 → 0.5.0.beta4

data/lib/socialization/actors/follower.rb

@@ -12,6 +12,8 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
+      after_destroy { Socialization.follow_model.remove_followables(self) }
+
       # Specifies if self can follow {Followable} objects.
       #
       # @return [Boolean]

data/lib/socialization/actors/liker.rb

@@ -12,6 +12,8 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
+      after_destroy { Socialization.like_model.remove_likeables(self) }
+
       # Specifies if self can like {Likeable} objects.
       #
       # @return [Boolean]

data/lib/socialization/actors/mentioner.rb

@@ -12,6 +12,8 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
+      after_destroy { Socialization.mention_model.remove_mentionables(self) }
+
       # Specifies if self can mention {Mentionable} objects.
       #
       # @return [Boolean]

data/lib/socialization/stores/active_record/follow.rb

@@ -98,6 +98,18 @@ module Socialization
           end
         end
 
+        # Remove all the followers for followable
+        def remove_followers(followable)
+          self.where(:followable_type => followable.class.name.classify).
+               where(:followable_id => followable.id).destroy_all
+        end
+
+        # Remove all the followables for follower
+        def remove_followables(follower)
+          self.where(:follower_type => follower.class.name.classify).
+               where(:follower_id => follower.id).destroy_all
+        end
+
       private
         def follow_for(follower, followable)
           followed_by(follower).following(followable)

data/lib/socialization/stores/active_record/like.rb

@@ -98,6 +98,18 @@ module Socialization
           end
         end
 
+        # Remove all the likers for likeable
+        def remove_likers(likeable)
+          self.where(:likeable_type => likeable.class.name.classify).
+               where(:likeable_id => likeable.id).destroy_all
+        end
+
+        # Remove all the likeables for liker
+        def remove_likeables(liker)
+          self.where(:liker_type => liker.class.name.classify).
+               where(:liker_id => liker.id).destroy_all
+        end
+
       private
         def like_for(liker, likeable)
           liked_by(liker).liking( likeable)

data/lib/socialization/stores/active_record/mention.rb

@@ -98,6 +98,18 @@ module Socialization
           end
         end
 
+        # Remove all the mentioners for mentionable
+        def remove_mentioners(mentionable)
+          self.where(:mentionable_type => mentionable.class.name.classify).
+               where(:mentionable_id => mentionable.id).destroy_all
+        end
+
+        # Remove all the mentionables for mentioner
+        def remove_mentionables(mentioner)
+          self.where(:mentioner_type => mentioner.class.name.classify).
+               where(:mentioner_id => mentioner.id).destroy_all
+        end
+
       private
         def mention_for(mentioner, mentionable)
           mentioned_by(mentioner).mentioning(mentionable)

data/lib/socialization/stores/redis/base.rb

@@ -1,6 +1,123 @@
 module Socialization
   module RedisStores
     class Base
-    end
-  end
-end
+
+      class << self
+      protected
+        def actors(victim, klass, options = {})
+          if options[:pluck]
+            Socialization.redis.smembers(generate_forward_key(victim)).inject([]) do |result, element|
+              result << element.match(/\:(\d+)$/)[1] if element.match(/^#{klass}\:/)
+            end
+          else
+            actors_relation(victim, klass, options).all
+          end
+        end
+
+        def actors_relation(victim, klass, options = {})
+          ids = actors(victim, klass, :pluck => :id)
+          klass.where("#{klass.table_name}.id IN (?)", ids)
+        end
+
+        def victims_relation(actor, klass, options = {})
+          ids = victims(actor, klass, :pluck => :id)
+          klass.where("#{klass.table_name}.id IN (?)", ids)
+        end
+
+        def victims(actor, klass, options = {})
+          if options[:pluck]
+            Socialization.redis.smembers(generate_backward_key(actor)).inject([]) do |result, element|
+              result << element.match(/\:(\d+)$/)[1] if element.match(/^#{klass}\:/)
+            end
+          else
+            victims_relation(actor, klass, options).all
+          end
+        end
+
+        def relation!(actor, victim, options = {})
+          unless options[:skip_check] || relation?(actor, victim)
+            Socialization.redis.sadd generate_forward_key(victim), generate_redis_value(actor)
+            Socialization.redis.sadd generate_backward_key(actor), generate_redis_value(victim)
+            call_after_create_hooks(actor, victim)
+            true
+          else
+            false
+          end
+        end
+
+        def unrelation!(actor, victim, options = {})
+          if options[:skip_check] || relation?(actor, victim)
+            Socialization.redis.srem generate_forward_key(victim), generate_redis_value(actor)
+            Socialization.redis.srem generate_backward_key(actor), generate_redis_value(victim)
+            call_after_destroy_hooks(actor, victim)
+            true
+          else
+            false
+          end
+        end
+
+        def relation?(actor, victim)
+          Socialization.redis.sismember generate_forward_key(victim), generate_redis_value(actor)
+        end
+
+        def remove_actor_relations(victim)
+          forward_key = generate_forward_key(victim)
+          actors = Socialization.redis.smembers forward_key
+          Socialization.redis.del forward_key
+          actors.each do |actor|
+            Socialization.redis.srem generate_backward_key(actor), generate_redis_value(victim)
+          end
+          true
+        end
+
+        def remove_victim_relations(actor)
+          backward_key = generate_backward_key(actor)
+          victims = Socialization.redis.smembers backward_key
+          Socialization.redis.del backward_key
+          victims.each do |victim|
+            Socialization.redis.srem generate_forward_key(victim), generate_redis_value(actor)
+          end
+          true
+        end
+
+
+      private
+        def key_type_to_type_names(klass)
+          if klass.name.match(/Follow$/)
+            ['follower', 'followable']
+          elsif klass.name.match(/Like$/)
+            ['liker', 'likeable']
+          elsif klass.name.match(/Mention$/)
+            ['mentioner', 'mentionable']
+          else
+            raise ArgumentError.new("Can't find matching type for #{klass}.")
+          end
+        end
+
+        def generate_forward_key(victim)
+          keys = key_type_to_type_names(self)
+          if victim.is_a?(String)
+            "#{keys[0].pluralize.capitalize}:#{victim}"
+          else
+            "#{keys[0].pluralize.capitalize}:#{victim.class}:#{victim.id}"
+          end
+        end
+
+        def generate_backward_key(actor)
+          keys = key_type_to_type_names(self)
+          if actor.is_a?(String)
+            "#{keys[1].pluralize.capitalize}:#{actor}"
+          else
+            "#{keys[1].pluralize.capitalize}:#{actor.class}:#{actor.id}"
+          end
+        end
+
+        def generate_redis_value(obj)
+          "#{obj.class.name}:#{obj.id}"
+        end
+
+      end # class << self
+
+    end # Base
+  end # RedisStores
+end # Socialization

data/lib/socialization/stores/redis/follow.rb

@@ -1,5 +1,3 @@
-# require File.expand_path(File.dirname(__FILE__)) + '/base'
-
 module Socialization
   module RedisStores
     class Follow < Socialization::RedisStores::Base
@@ -8,91 +6,16 @@ module Socialization
       extend Socialization::RedisStores::Mixins::Base
 
       class << self
-        def follow!(follower, followable)
-          unless follows?(follower, followable)
-            Socialization.redis.sadd generate_followers_key(follower, followable), follower.id
-            Socialization.redis.sadd generate_followables_key(follower, followable), followable.id
-
-            call_after_create_hooks(follower, followable)
-            true
-          else
-            false
-          end
-        end
-
-        def unfollow!(follower, followable)
-          if follows?(follower, followable)
-            Socialization.redis.srem generate_followers_key(follower, followable), follower.id
-            Socialization.redis.srem generate_followables_key(follower, followable), followable.id
-
-            call_after_destroy_hooks(follower, followable)
-            true
-          else
-            false
-          end
-        end
-
-        def follows?(follower, followable)
-          Socialization.redis.sismember generate_followers_key(follower, followable), follower.id
-        end
-
-        # Returns an ActiveRecord::Relation of all the followers of a certain type that are following followable
-        def followers_relation(followable, klass, opts = {})
-          ids = followers(followable, klass, :pluck => :id)
-          klass.where('id IN (?)', ids)
-        end
-
-        # Returns all the followers of a certain type that are following followable
-        def followers(followable, klass, opts = {})
-          if opts[:pluck]
-            Socialization.redis.smembers(generate_followers_key(klass, followable)).map { |id|
-              id.to_i if id.is_integer?
-            }
-          else
-            followers_relation(followable, klass, opts).all
-          end
-        end
-
-        # Returns an ActiveRecord::Relation of all the followables of a certain type that are followed by follower
-        def followables_relation(follower, klass, opts = {})
-          ids = followables(follower, klass, :pluck => :id)
-          klass.where('id IN (?)', ids)
-        end
-
-        # Returns all the followables of a certain type that are followed by follower
-        def followables(follower, klass, opts = {})
-          if opts[:pluck]
-            Socialization.redis.smembers(generate_followables_key(follower, klass)).map { |id|
-              id.to_i if id.is_integer?
-            }
-          else
-            followables_relation(follower, klass, opts).all
-          end
-        end
-
-      private
-        def generate_followers_key(follower, followable)
-          raise ArgumentError.new("`followable` needs to be an acts_as_followable objecs, not a class.") if followable.class == Class
-          follower_class = if follower.class == Class
-            follower
-          else
-            follower.class
-          end
-
-          "Followers:#{followable.class}:#{followable.id}:#{follower_class}"
-        end
-
-        def generate_followables_key(follower, followable)
-          raise ArgumentError.new("`follower` needs to be an acts_as_follower object, not a class.") if follower.class == Class
-          followable_class = if followable.class == Class
-            followable
-          else
-            followable.class
-          end
-
-          "Followables:#{follower.class}:#{follower.id}:#{followable_class}"
-        end
-      end # class << self
+        alias_method :follow!, :relation!;                          public :follow!
+        alias_method :unfollow!, :unrelation!;                      public :unfollow!
+        alias_method :follows?, :relation?;                         public :follows?
+        alias_method :followers_relation, :actors_relation;         public :followers_relation
+        alias_method :followers, :actors;                           public :followers
+        alias_method :followables_relation, :victims_relation;      public :followables_relation
+        alias_method :followables, :victims;                        public :followables
+        alias_method :remove_followers, :remove_actor_relations;    public :remove_followers
+        alias_method :remove_followables, :remove_victim_relations; public :remove_followables
+      end
 
     end
   end

data/lib/socialization/stores/redis/like.rb

@@ -1,5 +1,3 @@
-# require File.expand_path(File.dirname(__FILE__)) + '/base'
-
 module Socialization
   module RedisStores
     class Like < Socialization::RedisStores::Base
@@ -8,122 +6,16 @@ module Socialization
       extend Socialization::RedisStores::Mixins::Base
 
       class << self
-        def like!(liker, likeable)
-          unless likes?(liker, likeable)
-            Socialization.redis.sadd generate_likers_key(liker, likeable), liker.id
-            Socialization.redis.sadd generate_likeables_key(liker, likeable), likeable.id
-
-            call_after_create_hooks(liker, likeable)
-            liker.touch if [:all, :liker].include?(touch) && liker.respond_to?(:touch)
-            likeable.touch if [:all, :likeable].include?(touch) && likeable.respond_to?(:touch)
-            true
-          else
-            false
-          end
-        end
-
-        def unlike!(liker, likeable)
-          if likes?(liker, likeable)
-            Socialization.redis.srem generate_likers_key(liker, likeable), liker.id
-            Socialization.redis.srem generate_likeables_key(liker, likeable), likeable.id
-
-            call_after_destroy_hooks(liker, likeable)
-            liker.touch if [:all, :liker].include?(touch) && liker.respond_to?(:touch)
-            likeable.touch if [:all, :likeable].include?(touch) && likeable.respond_to?(:touch)
-            true
-          else
-            false
-          end
-        end
-
-        def likes?(liker, likeable)
-          Socialization.redis.sismember generate_likers_key(liker, likeable), liker.id
-        end
-
-        # Returns an ActiveRecord::Relation of all the likers of a certain type that are likeing likeable
-        def likers_relation(likeable, klass, opts = {})
-          ids = likers(likeable, klass, :pluck => :id)
-          klass.where('id IN (?)', ids)
-        end
-
-        # Returns all the likers of a certain type that are likeing likeable
-        def likers(likeable, klass, opts = {})
-          if opts[:pluck]
-            Socialization.redis.smembers(generate_likers_key(klass, likeable)).map { |id|
-              id.to_i if id.is_integer?
-            }
-          else
-            likers_relation(likeable, klass, opts).all
-          end
-        end
-
-        # Returns an ActiveRecord::Relation of all the likeables of a certain type that are liked by liker
-        def likeables_relation(liker, klass, opts = {})
-          ids = likeables(liker, klass, :pluck => :id)
-          klass.where('id IN (?)', ids)
-        end
-
-        # Returns all the likeables of a certain type that are liked by liker
-        def likeables(liker, klass, opts = {})
-          if opts[:pluck]
-            Socialization.redis.smembers(generate_likeables_key(liker, klass)).map { |id|
-              id.to_i if id.is_integer?
-            }
-          else
-            likeables_relation(liker, klass, opts).all
-          end
-        end
-
-        def touch(what = nil)
-          if what.nil?
-            @touch || false
-          else
-            raise ArgumentError unless [:all, :liker, :likeable, false, nil].include?(what)
-            @touch = what
-          end
-        end
-
-        def after_like(method)
-          raise ArgumentError unless method.is_a?(Symbol) || method.nil?
-          @after_create_hook = method
-        end
-
-        def after_unlike(method)
-          raise ArgumentError unless method.is_a?(Symbol) || method.nil?
-          @after_destroy_hook = method
-        end
-
-      private
-        def call_after_create_hooks(liker, likeable)
-          self.send(@after_create_hook, liker, likeable) if @after_create_hook
-        end
-
-        def call_after_destroy_hooks(liker, likeable)
-          self.send(@after_destroy_hook, liker, likeable) if @after_destroy_hook
-        end
-
-        def generate_likers_key(liker, likeable)
-          raise ArgumentError.new("`likeable` needs to be an acts_as_likeable objecs, not a class.") if likeable.class == Class
-          liker_class = if liker.class == Class
-            liker
-          else
-            liker.class
-          end
-
-          "Likers:#{likeable.class}:#{likeable.id}:#{liker_class}"
-        end
-
-        def generate_likeables_key(liker, likeable)
-          raise ArgumentError.new("`liker` needs to be an acts_as_liker object, not a class.") if liker.class == Class
-          likeable_class = if likeable.class == Class
-            likeable
-          else
-            likeable.class
-          end
-
-          "Likeables:#{liker.class}:#{liker.id}:#{likeable_class}"
-        end
-      end # class << self
+        alias_method :like!, :relation!;                          public :like!
+        alias_method :unlike!, :unrelation!;                      public :unlike!
+        alias_method :likes?, :relation?;                         public :likes?
+        alias_method :likers_relation, :actors_relation;          public :likers_relation
+        alias_method :likers, :actors;                            public :likers
+        alias_method :likeables_relation, :victims_relation;      public :likeables_relation
+        alias_method :likeables, :victims;                        public :likeables
+        alias_method :remove_likers, :remove_actor_relations;     public :remove_likers
+        alias_method :remove_likeables, :remove_victim_relations; public :remove_likeables
+      end
 
     end
   end

data/lib/socialization/stores/redis/mention.rb

@@ -1,5 +1,3 @@
-# require File.expand_path(File.dirname(__FILE__)) + '/base'
-
 module Socialization
   module RedisStores
     class Mention < Socialization::RedisStores::Base
@@ -8,91 +6,16 @@ module Socialization
       extend Socialization::RedisStores::Mixins::Base
 
       class << self
-        def mention!(mentioner, mentionable)
-          unless mentions?(mentioner, mentionable)
-            Socialization.redis.sadd generate_mentioners_key(mentioner, mentionable), mentioner.id
-            Socialization.redis.sadd generate_mentionables_key(mentioner, mentionable), mentionable.id
-
-            call_after_create_hooks(mentioner, mentionable)
-            true
-          else
-            false
-          end
-        end
-
-        def unmention!(mentioner, mentionable)
-          if mentions?(mentioner, mentionable)
-            Socialization.redis.srem generate_mentioners_key(mentioner, mentionable), mentioner.id
-            Socialization.redis.srem generate_mentionables_key(mentioner, mentionable), mentionable.id
-
-            call_after_destroy_hooks(mentioner, mentionable)
-            true
-          else
-            false
-          end
-        end
-
-        def mentions?(mentioner, mentionable)
-          Socialization.redis.sismember generate_mentioners_key(mentioner, mentionable), mentioner.id
-        end
-
-        # Returns an ActiveRecord::Relation of all the mentioners of a certain type that are mentioning mentionable
-        def mentioners_relation(mentionable, klass, opts = {})
-          ids = mentioners(mentionable, klass, :pluck => :id)
-          klass.where('id IN (?)', ids)
-        end
-
-        # Returns all the mentioners of a certain type that are mentioning mentionable
-        def mentioners(mentionable, klass, opts = {})
-          if opts[:pluck]
-            Socialization.redis.smembers(generate_mentioners_key(klass, mentionable)).map { |id|
-              id.to_i if id.is_integer?
-            }
-          else
-            mentioners_relation(mentionable, klass, opts).all
-          end
-        end
-
-        # Returns an ActiveRecord::Relation of all the mentionables of a certain type that are mentioned by mentioner
-        def mentionables_relation(mentioner, klass, opts = {})
-          ids = mentionables(mentioner, klass, :pluck => :id)
-          klass.where('id IN (?)', ids)
-        end
-
-        # Returns all the mentionables of a certain type that are mentioned by mentioner
-        def mentionables(mentioner, klass, opts = {})
-          if opts[:pluck]
-            Socialization.redis.smembers(generate_mentionables_key(mentioner, klass)).map { |id|
-              id.to_i if id.is_integer?
-            }
-          else
-            mentionables_relation(mentioner, klass, opts).all
-          end
-        end
-
-      private
-        def generate_mentioners_key(mentioner, mentionable)
-          raise ArgumentError.new("`mentionable` needs to be an acts_as_mentionable objecs, not a class.") if mentionable.class == Class
-          mentioner_class = if mentioner.class == Class
-            mentioner
-          else
-            mentioner.class
-          end
-
-          "Mentioners:#{mentionable.class}:#{mentionable.id}:#{mentioner_class}"
-        end
-
-        def generate_mentionables_key(mentioner, mentionable)
-          raise ArgumentError.new("`mentioner` needs to be an acts_as_mentioner object, not a class.") if mentioner.class == Class
-          mentionable_class = if mentionable.class == Class
-            mentionable
-          else
-            mentionable.class
-          end
-
-          "Mentionables:#{mentioner.class}:#{mentioner.id}:#{mentionable_class}"
-        end
-      end # class << self
+        alias_method :mention!, :relation!;                          public :mention!
+        alias_method :unmention!, :unrelation!;                      public :unmention!
+        alias_method :mentions?, :relation?;                         public :mentions?
+        alias_method :mentioners_relation, :actors_relation;         public :mentioners_relation
+        alias_method :mentioners, :actors;                           public :mentioners
+        alias_method :mentionables_relation, :victims_relation;      public :mentionables_relation
+        alias_method :mentionables, :victims;                        public :mentionables
+        alias_method :remove_mentioners, :remove_actor_relations;    public :remove_mentioners
+        alias_method :remove_mentionables, :remove_victim_relations; public :remove_mentionables
+      end
 
     end
   end

data/lib/socialization/version.rb

@@ -1,3 +1,3 @@
 module Socialization
-  VERSION = "0.5.0.beta3"
+  VERSION = "0.5.0.beta4"
 end

data/lib/socialization/victims/followable.rb

@@ -12,6 +12,8 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
+      after_destroy { Socialization.follow_model.remove_followers(self) }
+
       # Specifies if self can be followed.
       #
       # @return [Boolean]

data/lib/socialization/victims/likeable.rb

@@ -12,6 +12,8 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
+      after_destroy { Socialization.like_model.remove_likers(self) }
+
       # Specifies if self can be liked.
       #
       # @return [Boolean]

data/lib/socialization/victims/mentionable.rb

@@ -12,6 +12,8 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
+      after_destroy { Socialization.mention_model.remove_mentioners(self) }
+
       # Specifies if self can be mentioned.
       #
       # @return [Boolean]

data/test/actors/follower_test.rb

@@ -98,5 +98,17 @@ class FollowerTest < Test::Unit::TestCase
       end
     end
 
+    context "deleting a follower" do
+      setup do
+        @follower = ImAFollower.create
+        @follower.follow!(@followable)
+      end
+
+      should "remove follow relationships" do
+        Socialization.follow_model.expects(:remove_followables).with(@follower)
+        @follower.destroy
+      end
+    end
+
   end
 end

data/test/actors/liker_test.rb

@@ -98,5 +98,9 @@ class LikerTest < Test::Unit::TestCase
       end
     end
 
+    should "remove like relationships" do
+      Socialization.like_model.expects(:remove_likeables).with(@liker)
+      @liker.destroy
+    end
   end
 end

data/test/actors/mentioner_test.rb

@@ -97,5 +97,10 @@ class MentionerTest < Test::Unit::TestCase
         @mentioner.mentionees_relation(@mentionable.class, { :foo => :bar })
       end
     end
+
+    should "remove mention relationships" do
+      Socialization.mention_model.expects(:remove_mentionables).with(@mentioner)
+      @mentioner.destroy
+    end
   end
 end

data/test/stores/active_record/follow_store_test.rb

@@ -108,6 +108,23 @@ class ActiveRecordFollowStoreTest < Test::Unit::TestCase
       end
     end
 
+    context "#remove_followers" do
+      should "delete all followers relationships for a followable" do
+        @follower.follow!(@followable)
+        assert_equal 1, @followable.followers(@follower.class).count
+        @klass.remove_followers(@followable)
+        assert_equal 0, @followable.followers(@follower.class).count
+      end
+    end
+
+    context "#remove_followables" do
+      should "delete all followables relationships for a follower" do
+        @follower.follow!(@followable)
+        assert_equal 1, @follower.followables(@followable.class).count
+        @klass.remove_followables(@follower)
+        assert_equal 0, @follower.followables(@followable.class).count
+      end
+    end
   end
 
   # Helpers