socialization 0.4.0 → 0.5.0.beta

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

@@ -0,0 +1,143 @@
+module Socialization
+  module ActiveRecordStores
+    class FollowStore < ActiveRecord::Base
+      belongs_to :follower,   :polymorphic => true
+      belongs_to :followable, :polymorphic => true
+
+      scope :followed_by, lambda { |follower| where(
+        :follower_type   => follower.class.table_name.classify,
+        :follower_id     => follower.id)
+      }
+
+      scope :following,   lambda { |followable| where(
+        :followable_type => followable.class.table_name.classify,
+        :followable_id   => followable.id)
+      }
+
+      @@after_create_hook = nil
+      @@after_destroy_hook = nil
+
+      class << self
+        def table_name
+          'follows'
+        end
+
+        def follow!(follower, followable)
+          unless follows?(follower, followable)
+            self.create! do |follow|
+              follow.follower = follower
+              follow.followable = followable
+            end
+            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)
+            follow_for(follower, followable).destroy_all
+            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)
+          !follow_for(follower, followable).empty?
+        end
+
+        # Returns an ActiveRecord::Relation of all the followers of a certain type that are following followable
+        def followers_relation(followable, klass, opts = {})
+          rel = klass.where(:id =>
+            self.select(:follower_id).
+              where(:follower_type => klass.table_name.classify).
+              where(:followable_type => followable.class.to_s).
+              where(:followable_id => followable.id)
+          )
+
+          if opts[:pluck]
+            rel.pluck(opts[:pluck])
+          else
+            rel
+          end
+        end
+
+        # Returns all the followers of a certain type that are following followable
+        def followers(followable, klass, opts = {})
+          rel = followers_relation(followable, klass, opts)
+          if rel.is_a?(ActiveRecord::Relation)
+            rel.all
+          else
+            rel
+          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 = {})
+          rel = klass.where(:id =>
+            self.select(:followable_id).
+              where(:followable_type => klass.table_name.classify).
+              where(:follower_type => follower.class.to_s).
+              where(:follower_id => follower.id)
+          )
+
+          if opts[:pluck]
+            rel.pluck(opts[:pluck])
+          else
+            rel
+          end
+        end
+
+        # Returns all the followables of a certain type that are followed by follower
+        def followables(follower, klass, opts = {})
+          rel = followables_relation(follower, klass, opts)
+          if rel.is_a?(ActiveRecord::Relation)
+            rel.all
+          else
+            rel
+          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 follow_for(follower, followable)
+          followed_by(follower).following(followable)
+        end
+      end # class << self
+
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+module Socialization
+  module ActiveRecordStores
+    class LikeStore < ActiveRecord::Base
+      belongs_to :liker,    :polymorphic => true
+      belongs_to :likeable, :polymorphic => true
+
+      scope :liked_by, lambda { |liker| where(
+        :liker_type    => liker.class.table_name.classify,
+        :liker_id      => liker.id)
+      }
+
+      scope :liking,   lambda { |likeable| where(
+        :likeable_type => likeable.class.table_name.classify,
+        :likeable_id   => likeable.id)
+      }
+
+      @@after_create_hook = nil
+      @@after_destroy_hook = nil
+
+      class << self
+        def table_name
+          'likes'
+        end
+
+        def like!(liker, likeable)
+          unless likes?(liker, likeable)
+            self.create! do |like|
+              like.liker = liker
+              like.likeable = likeable
+            end
+            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)
+            like_for(liker, likeable).destroy_all
+            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)
+          !like_for(liker, likeable).empty?
+        end
+
+        # Returns an ActiveRecord::Relation of all the likers of a certain type that are liking  likeable
+        def likers_relation(likeable, klass, opts = {})
+          rel = klass.where(:id =>
+            self.select(:liker_id).
+              where(:liker_type => klass.table_name.classify).
+              where(:likeable_type => likeable.class.to_s).
+              where(:likeable_id => likeable.id)
+          )
+
+          if opts[:pluck]
+            rel.pluck(opts[:pluck])
+          else
+            rel
+          end
+        end
+
+        # Returns all the likers of a certain type that are liking  likeable
+        def likers(likeable, klass, opts = {})
+          rel = likers_relation(likeable, klass, opts)
+          if rel.is_a?(ActiveRecord::Relation)
+            rel.all
+          else
+            rel
+          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 = {})
+          rel = klass.where(:id =>
+            self.select(:likeable_id).
+              where(:likeable_type => klass.table_name.classify).
+              where(:liker_type => liker.class.to_s).
+              where(:liker_id => liker.id)
+          )
+
+          if opts[:pluck]
+            rel.pluck(opts[:pluck])
+          else
+            rel
+          end
+        end
+
+        # Returns all the likeables of a certain type that are liked by liker
+        def likeables(liker, klass, opts = {})
+          rel = likeables_relation(liker, klass, opts)
+          if rel.is_a?(ActiveRecord::Relation)
+            rel.all
+          else
+            rel
+          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 like_for(liker, likeable)
+          liked_by(liker).liking( likeable)
+        end
+      end # class << self
+
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+module Socialization
+  module ActiveRecordStores
+    class MentionStore < ActiveRecord::Base
+      belongs_to :mentioner,   :polymorphic => true
+      belongs_to :mentionable, :polymorphic => true
+
+      scope :mentioned_by, lambda { |mentioner| where(
+        :mentioner_type   => mentioner.class.table_name.classify,
+        :mentioner_id     => mentioner.id)
+      }
+
+      scope :mentioning,   lambda { |mentionable| where(
+        :mentionable_type => mentionable.class.table_name.classify,
+        :mentionable_id   => mentionable.id)
+      }
+
+      @@after_create_hook = nil
+      @@after_destroy_hook = nil
+
+      class << self
+        def table_name
+          'mentions'
+        end
+
+        def mention!(mentioner, mentionable)
+          unless mentions?(mentioner, mentionable)
+            self.create! do |mention|
+              mention.mentioner = mentioner
+              mention.mentionable = mentionable
+            end
+            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)
+            mention_for(mentioner, mentionable).destroy_all
+            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)
+          !mention_for(mentioner, mentionable).empty?
+        end
+
+        # Returns an ActiveRecord::Relation of all the mentioners of a certain type that are mentioning mentionable
+        def mentioners_relation(mentionable, klass, opts = {})
+          rel = klass.where(:id =>
+            self.select(:mentioner_id).
+              where(:mentioner_type => klass.table_name.classify).
+              where(:mentionable_type => mentionable.class.to_s).
+              where(:mentionable_id => mentionable.id)
+          )
+
+          if opts[:pluck]
+            rel.pluck(opts[:pluck])
+          else
+            rel
+          end
+        end
+
+        # Returns all the mentioners of a certain type that are mentioning mentionable
+        def mentioners(mentionable, klass, opts = {})
+          rel = mentioners_relation(mentionable, klass, opts)
+          if rel.is_a?(ActiveRecord::Relation)
+            rel.all
+          else
+            rel
+          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 = {})
+          rel = klass.where(:id =>
+            self.select(:mentionable_id).
+              where(:mentionable_type => klass.table_name.classify).
+              where(:mentioner_type => mentioner.class.to_s).
+              where(:mentioner_id => mentioner.id)
+          )
+
+          if opts[:pluck]
+            rel.pluck(opts[:pluck])
+          else
+            rel
+          end
+        end
+
+        # Returns all the mentionables of a certain type that are mentioned by mentioner
+        def mentionables(mentioner, klass, opts = {})
+          rel = mentionables_relation(mentioner, klass, opts)
+          if rel.is_a?(ActiveRecord::Relation)
+            rel.all
+          else
+            rel
+          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 mention_for(mentioner, mentionable)
+          mentioned_by(mentioner).mentioning(mentionable)
+        end
+      end # class << self
+
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Socialization
+  module RedisStores
+    class Base
+      @@after_create_hook = nil
+      @@after_destroy_hook = nil
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Socialization
+  class << self
+    def redis
+      @redis ||= Redis.new
+    end
+
+    def redis=(redis)
+      @redis = redis
+    end
+  end
+end