twrk-socialization 0.0.1

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

@@ -0,0 +1,121 @@
+module Socialization
+  module ActiveRecordStores
+    class Like < ActiveRecord::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Like
+      extend Socialization::ActiveRecordStores::Mixins::Base
+
+      belongs_to :liker,    :polymorphic => true
+      belongs_to :likeable, :polymorphic => true
+
+      scope :liked_by, lambda { |liker| where(
+        :liker_type    => liker.class.name.classify,
+        :liker_id      => liker.id)
+      }
+
+      scope :liking,   lambda { |likeable| where(
+        :likeable_id   => likeable.id)
+      }
+
+      class << self
+        def like!(liker, likeable)
+          unless likes?(liker, likeable)
+            self.create! do |like|
+              like.liker = liker
+              like.likeable = likeable
+            end
+            update_counter(liker, likees_count: +1)
+            update_counter(likeable, likers_count: +1)
+            call_after_create_hooks(liker, likeable)
+            true
+          else
+            false
+          end
+        end
+
+        def unlike!(liker, likeable)
+          if likes?(liker, likeable)
+            like_for(liker, likeable).destroy_all
+            update_counter(liker, likees_count: -1)
+            update_counter(likeable, likers_count: -1)
+            call_after_destroy_hooks(liker, likeable)
+            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.name.classify).
+              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.to_a
+          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(: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.to_a
+          else
+            rel
+          end
+        end
+
+        # Remove all the likers for likeable
+        def remove_likers(likeable)
+          self.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)
+        end
+      end # class << self
+
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Socialization
+  module ActiveRecordStores
+    class Mention < ActiveRecord::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Mention
+      extend Socialization::ActiveRecordStores::Mixins::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)
+      }
+
+      class << self
+        def mention!(mentioner, mentionable)
+          unless mentions?(mentioner, mentionable)
+            self.create! do |mention|
+              mention.mentioner = mentioner
+              mention.mentionable = mentionable
+            end
+            update_counter(mentioner, mentionees_count: +1)
+            update_counter(mentionable, mentioners_count: +1)
+            call_after_create_hooks(mentioner, mentionable)
+            true
+          else
+            false
+          end
+        end
+
+        def unmention!(mentioner, mentionable)
+          if mentions?(mentioner, mentionable)
+            mention_for(mentioner, mentionable).destroy_all
+            update_counter(mentioner, mentionees_count: -1)
+            update_counter(mentionable, mentioners_count: -1)
+            call_after_destroy_hooks(mentioner, mentionable)
+            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.to_a
+          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.to_a
+          else
+            rel
+          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)
+        end
+      end # class << self
+
+    end
+  end
+end

data/lib/socialization/stores/active_record/mixins/base.rb

@@ -0,0 +1,12 @@
+module Socialization
+  module ActiveRecordStores
+    module Mixins
+      module Base
+        def update_counter(model, counter)
+          column_name, _ = counter.first
+          model.class.update_counters model.id, counter if model.respond_to?(column_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Base
+        def touch_dependents(actor, victim)
+          actor.touch if touch_actor?(actor)
+          victim.touch if touch_victim?(victim)
+        end
+
+        def touch_actor?(actor)
+          return false unless actor.respond_to?(:touch)
+          touch == :all || touch.to_s =~ /er$/i
+        end
+
+        def touch_victim?(victim)
+          return false unless victim.respond_to?(:touch)
+          touch == :all || touch.to_s =~ /able$/i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Follow
+
+      public
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise Socialization::ArgumentError unless [:all, :follower, :followable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_follow(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unfollow(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      protected
+        def call_after_create_hooks(follower, followable)
+          self.send(@after_create_hook, follower, followable) if @after_create_hook
+          touch_dependents(follower, followable)
+        end
+
+        def call_after_destroy_hooks(follower, followable)
+          self.send(@after_destroy_hook, follower, followable) if @after_destroy_hook
+          touch_dependents(follower, followable)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Like
+
+      public
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise Socialization::ArgumentError unless [:all, :liker, :likeable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_like(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unlike(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      protected
+        def call_after_create_hooks(liker, likeable)
+          self.send(@after_create_hook, liker, likeable) if @after_create_hook
+          touch_dependents(liker, likeable)
+        end
+
+        def call_after_destroy_hooks(liker, likeable)
+          self.send(@after_destroy_hook, liker, likeable) if @after_destroy_hook
+          touch_dependents(liker, likeable)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Socialization
+  module Stores
+    module Mixins
+      module Mention
+
+      public
+        def touch(what = nil)
+          if what.nil?
+            @touch || false
+          else
+            raise Socialization::ArgumentError unless [:all, :mentioner, :mentionable, false, nil].include?(what)
+            @touch = what
+          end
+        end
+
+        def after_mention(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_create_hook = method
+        end
+
+        def after_unmention(method)
+          raise Socialization::ArgumentError unless method.is_a?(Symbol) || method.nil?
+          @after_destroy_hook = method
+        end
+
+      protected
+        def call_after_create_hooks(mentioner, mentionable)
+          self.send(@after_create_hook, mentioner, mentionable) if @after_create_hook
+          touch_dependents(mentioner, mentionable)
+        end
+
+        def call_after_destroy_hooks(mentioner, mentionable)
+          self.send(@after_destroy_hook, mentioner, mentionable) if @after_destroy_hook
+          touch_dependents(mentioner, mentionable)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Socialization
+  module RedisStores
+    class Base
+
+      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}\:/)
+              result
+            end
+          else
+            actors_relation(victim, klass, options).to_a
+          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}\:/)
+              result
+            end
+          else
+            victims_relation(actor, klass, options).to_a
+          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 Socialization::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/config.rb

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

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

@@ -0,0 +1,22 @@
+module Socialization
+  module RedisStores
+    class Follow < Socialization::RedisStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Follow
+      extend Socialization::RedisStores::Mixins::Base
+
+      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
+end

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

@@ -0,0 +1,22 @@
+module Socialization
+  module RedisStores
+    class Like < Socialization::RedisStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Like
+      extend Socialization::RedisStores::Mixins::Base
+
+      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
+end

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

@@ -0,0 +1,22 @@
+module Socialization
+  module RedisStores
+    class Mention < Socialization::RedisStores::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Mention
+      extend Socialization::RedisStores::Mixins::Base
+
+      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
+end

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

@@ -0,0 +1,8 @@
+module Socialization
+  module RedisStores
+    module Mixins
+      module Base
+      end
+    end
+  end
+end

data/lib/socialization/version.rb

@@ -0,0 +1,3 @@
+module Socialization
+  VERSION = "1.2.0"
+end

data/lib/socialization/victims/followable.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  class Base
+    def is_followable?
+      false
+    end
+    alias followable? is_followable?
+  end
+end
+
+module Socialization
+  module Followable
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.follow_model.remove_followers(self) }
+
+      # Specifies if self can be followed.
+      #
+      # @return [Boolean]
+      def is_followable?
+        true
+      end
+      alias followable? is_followable?
+
+      # Specifies if self is followed by a {Follower} object.
+      #
+      # @return [Boolean]
+      def followed_by?(follower)
+        raise Socialization::ArgumentError, "#{follower} is not follower!"  unless follower.respond_to?(:is_follower?) && follower.is_follower?
+        Socialization.follow_model.follows?(follower, self)
+      end
+
+      # Returns an array of {Follower}s following self.
+      #
+      # @param [Class] klass the {Follower} class to be included. 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
+
+      # 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 ActiveRecord::Relation
+      def followers_relation(klass, opts = {})
+        Socialization.follow_model.followers_relation(self, klass, opts)
+      end
+    end
+  end
+end