socialization 0.4.0 → 0.5.0.beta

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

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__)) + '/base'
+
+module Socialization
+  module RedisStores
+    class FollowStore < Socialization::RedisStores::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_hook(follower, followable)
+            follower.touch if [:all, :follower].include?(touch) && follower.respond_to?(:touch)
+            followable.touch if [:all, :followable].include?(touch) && followable.respond_to?(:touch)
+            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_hook(follower, followable)
+            follower.touch if [:all, :follower].include?(touch) && follower.respond_to?(:touch)
+            followable.touch if [:all, :followable].include?(touch) && followable.respond_to?(:touch)
+            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
+
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise ArgumentError unless [:all, :follower, :followable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_follow(method)
+          raise ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unfollow(method)
+          raise ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      private
+        def call_after_create_hook(follower, followable)
+          self.send(@after_create_hook, follower, followable) if @after_create_hook
+        end
+
+        def call_after_destroy_hook(follower, followable)
+          self.send(@after_destroy_hook, follower, followable) if @after_destroy_hook
+        end
+
+        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
+
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__)) + '/base'
+
+module Socialization
+  module RedisStores
+    class LikeStore < Socialization::RedisStores::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_hook(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_hook(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_hook(liker, likeable)
+          self.send(@after_create_hook, liker, likeable) if @after_create_hook
+        end
+
+        def call_after_destroy_hook(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
+
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__)) + '/base'
+
+module Socialization
+  module RedisStores
+    class MentionStore < Socialization::RedisStores::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_hook(mentioner, mentionable)
+            mentioner.touch if [:all, :mentioner].include?(touch) && mentioner.respond_to?(:touch)
+            mentionable.touch if [:all, :mentionable].include?(touch) && mentionable.respond_to?(:touch)
+            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_hook(mentioner, mentionable)
+            mentioner.touch if [:all, :mentioner].include?(touch) && mentioner.respond_to?(:touch)
+            mentionable.touch if [:all, :mentionable].include?(touch) && mentionable.respond_to?(:touch)
+            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
+
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise ArgumentError unless [:all, :mentioner, :mentionable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_mention(method)
+          raise ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unmention(method)
+          raise ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      private
+        def call_after_create_hook(mentioner, mentionable)
+          self.send(@after_create_hook, mentioner, mentionable) if @after_create_hook
+        end
+
+        def call_after_destroy_hook(mentioner, mentionable)
+          self.send(@after_destroy_hook, mentioner, mentionable) if @after_destroy_hook
+        end
+
+        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
+
+    end
+  end
+end

data/lib/socialization/version.rb

@@ -1,3 +1,3 @@
 module Socialization
-  VERSION = "0.4.0"
+  VERSION = "0.5.0.beta"
 end

data/lib/socialization/victims/followable.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  class Base
+    def is_followable?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Followable
+    extend ActiveSupport::Concern
+
+    included do
+      # Specifies if self can be followed.
+      #
+      # @return [Boolean]
+      def is_followable?
+        true
+      end
+
+      # Specifies if self is followed by a {Follower} object.
+      #
+      # @return [Boolean]
+      def followed_by?(follower)
+        raise ArgumentError, "#{follower} is not follower!"  unless follower.respond_to?(:is_follower?) && follower.is_follower?
+        Socialization.follow_model.follows?(follower, self)
+      end
+
+      # Returns a scope of the {Follower}s following self.
+      #
+      # @param [Class] klass the {Follower} class to be included in the scope. e.g. `User`
+      # @return [Array<Follower, Numeric>] An array of Follower objects or IDs
+      def followers(klass, opts = {})
+        Socialization.follow_model.followers(self, klass, opts)
+      end
+    end
+  end
+end

data/lib/socialization/victims/likeable.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  class Base
+    def is_likeable?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Likeable
+    extend ActiveSupport::Concern
+
+    included do
+      # Specifies if self can be liked.
+      #
+      # @return [Boolean]
+      def is_likeable?
+        true
+      end
+
+      # Specifies if self is liked by a {Liker} object.
+      #
+      # @return [Boolean]
+      def liked_by?(liker)
+        raise ArgumentError, "#{liker} is not liker!"  unless liker.respond_to?(:is_liker?) && liker.is_liker?
+        Socialization.like_model.likes?(liker, self)
+      end
+
+      # Returns a scope of the {Liker}s likeing self.
+      #
+      # @param [Class] klass the {Liker} class to be included in the scope. e.g. `User`.
+      # @return [Array<Liker, Numeric>] An array of Liker objects or IDs
+      def likers(klass, opts = {})
+        Socialization.like_model.likers(self, klass, opts)
+      end
+    end
+  end
+end