twrk-socialization 0.0.1

data/lib/generators/socialization/socialization_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+STORES = %w(active_record redis)
+
+class SocializationGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  source_root File.expand_path(File.join('templates'), File.dirname(__FILE__))
+  class_option :store, :type => :string, :default => 'active_record', :description => "Type of datastore"
+
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end
+  end
+
+  def create_migration_file
+    options[:store].downcase!
+    unless STORES.include?(options[:store])
+      puts "Invalid store '#{options[:store]}'. The following stores are valid: #{STORES.join(', ')}."
+      exit 1
+    end
+
+    copy_file "#{options[:store]}/model_follow.rb",  'app/models/follow.rb'
+    copy_file "#{options[:store]}/model_like.rb",    'app/models/like.rb'
+    copy_file "#{options[:store]}/model_mention.rb", 'app/models/mention.rb'
+
+    if options[:store] == 'active_record'
+      migration_template "#{options[:store]}/migration_follows.rb",  'db/migrate/create_follows.rb'
+      sleep 1 # wait a second to have a unique migration timestamp
+      migration_template "#{options[:store]}/migration_likes.rb",    'db/migrate/create_likes.rb'
+      sleep 1 # wait a second to have a unique migration timestamp
+      migration_template "#{options[:store]}/migration_mentions.rb", 'db/migrate/create_mentions.rb'
+    end
+  end
+end

data/lib/generators/socialization/templates/active_record/migration_follows.rb

@@ -0,0 +1,14 @@
+class CreateFollows < ActiveRecord::Migration
+  def change
+    create_table :follows do |t|
+      t.string  :follower_type
+      t.integer :follower_id
+      t.string  :followable_type
+      t.integer :followable_id
+      t.datetime :created_at
+    end
+
+    add_index :follows, ["follower_id", "follower_type"],     :name => "fk_follows"
+    add_index :follows, ["followable_id", "followable_type"], :name => "fk_followables"
+  end
+end

data/lib/generators/socialization/templates/active_record/migration_likes.rb

@@ -0,0 +1,14 @@
+class CreateLikes < ActiveRecord::Migration
+  def change
+    create_table :likes do |t|
+      t.string  :liker_type
+      t.integer :liker_id
+      t.string  :likeable_type
+      t.integer :likeable_id
+      t.datetime :created_at
+    end
+
+    add_index :likes, ["liker_id", "liker_type"],       :name => "fk_likes"
+    add_index :likes, ["likeable_id", "likeable_type"], :name => "fk_likeables"
+  end
+end

data/lib/generators/socialization/templates/active_record/migration_mentions.rb

@@ -0,0 +1,14 @@
+class CreateMentions < ActiveRecord::Migration
+  def change
+    create_table :mentions do |t|
+      t.string  :mentioner_type
+      t.integer :mentioner_id
+      t.string  :mentionable_type
+      t.integer :mentionable_id
+      t.datetime :created_at
+    end
+
+    add_index :mentions, ["mentioner_id", "mentioner_type"],   :name => "fk_mentions"
+    add_index :mentions, ["mentionable_id", "mentionable_type"], :name => "fk_mentionables"
+  end
+end

data/lib/generators/socialization/templates/active_record/model_follow.rb

@@ -0,0 +1,2 @@
+class Follow < Socialization::ActiveRecordStores::Follow
+end

data/lib/generators/socialization/templates/active_record/model_like.rb

@@ -0,0 +1,2 @@
+class Like < Socialization::ActiveRecordStores::Like
+end

data/lib/generators/socialization/templates/active_record/model_mention.rb

@@ -0,0 +1,2 @@
+class Mention < Socialization::ActiveRecordStores::Mention
+end

data/lib/generators/socialization/templates/redis/model_follow.rb

@@ -0,0 +1,2 @@
+class Follow < Socialization::RedisStores::Follow
+end

data/lib/generators/socialization/templates/redis/model_like.rb

@@ -0,0 +1,2 @@
+class Like < Socialization::RedisStores::Like
+end

data/lib/generators/socialization/templates/redis/model_mention.rb

@@ -0,0 +1,2 @@
+class Mention < Socialization::RedisStores::Mention
+end

data/lib/socialization/actors/follower.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  class Base
+    def is_follower?
+      false
+    end
+    alias follower? is_follower?
+  end
+end
+
+module Socialization
+  module Follower
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.follow_model.remove_followables(self) }
+
+      # Specifies if self can follow {Followable} objects.
+      #
+      # @return [Boolean]
+      def is_follower?
+        true
+      end
+      alias follower? is_follower?
+
+      # Create a new {Follow follow} relationship.
+      #
+      # @param [Followable] followable the object to be followed.
+      # @return [Boolean]
+      def follow!(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!"  unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.follow!(self, followable)
+      end
+
+      # Delete a {Follow follow} relationship.
+      #
+      # @param [Followable] followable the object to unfollow.
+      # @return [Boolean]
+      def unfollow!(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.unfollow!(self, followable)
+      end
+
+      # Toggles a {Follow follow} relationship.
+      #
+      # @param [Followable] followable the object to follow/unfollow.
+      # @return [Boolean]
+      def toggle_follow!(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        if follows?(followable)
+          unfollow!(followable)
+          false
+        else
+          follow!(followable)
+          true
+        end
+      end
+
+      # Specifies if self follows a {Followable} object.
+      #
+      # @param [Followable] followable the {Followable} object to test against.
+      # @return [Boolean]
+      def follows?(followable)
+        raise Socialization::ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
+        Socialization.follow_model.follows?(self, followable)
+      end
+
+      # Returns all the followables of a certain type that are followed by self
+      #
+      # @params [Followable] klass the type of {Followable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Followable, Numeric>] An array of Followable objects or IDs
+      def followables(klass, opts = {})
+        Socialization.follow_model.followables(self, klass, opts)
+      end
+      alias :followees :followables
+
+      # Returns a relation for all the followables of a certain type that are followed by self
+      #
+      # @params [Followable] klass the type of {Followable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def followables_relation(klass, opts = {})
+        Socialization.follow_model.followables_relation(self, klass, opts)
+      end
+      alias :followees_relation :followables_relation
+    end
+  end
+end

data/lib/socialization/actors/liker.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  class Base
+    def is_liker?
+      false
+    end
+    alias liker? is_liker?
+  end
+end
+
+module Socialization
+  module Liker
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.like_model.remove_likeables(self) }
+
+      # Specifies if self can like {Likeable} objects.
+      #
+      # @return [Boolean]
+      def is_liker?
+        true
+      end
+      alias liker? is_liker?
+
+      # Create a new {Like like} relationship.
+      #
+      # @param [Likeable] likeable the object to be liked.
+      # @return [Boolean]
+      def like!(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!"  unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.like!(self, likeable)
+      end
+
+      # Delete a {Like like} relationship.
+      #
+      # @param [Likeable] likeable the object to unlike.
+      # @return [Boolean]
+      def unlike!(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.unlike!(self, likeable)
+      end
+
+      # Toggles a {Like like} relationship.
+      #
+      # @param [Likeable] likeable the object to like/unlike.
+      # @return [Boolean]
+      def toggle_like!(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        if likes?(likeable)
+          unlike!(likeable)
+          false
+        else
+          like!(likeable)
+          true
+        end
+      end
+
+      # Specifies if self likes a {Likeable} object.
+      #
+      # @param [Likeable] likeable the {Likeable} object to test against.
+      # @return [Boolean]
+      def likes?(likeable)
+        raise Socialization::ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
+        Socialization.like_model.likes?(self, likeable)
+      end
+
+      # Returns all the likeables of a certain type that are liked by self
+      #
+      # @params [Likeable] klass the type of {Likeable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Likeable, Numeric>] An array of Likeable objects or IDs
+      def likeables(klass, opts = {})
+        Socialization.like_model.likeables(self, klass, opts)
+      end
+      alias :likees :likeables
+
+      # Returns a relation for all the likeables of a certain type that are liked by self
+      #
+      # @params [Likeable] klass the type of {Likeable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def likeables_relation(klass, opts = {})
+        Socialization.like_model.likeables_relation(self, klass, opts)
+      end
+      alias :likees_relation :likeables_relation
+    end
+  end
+end

data/lib/socialization/actors/mentioner.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  class Base
+    def is_mentioner?
+      false
+    end
+    alias mentioner? is_mentioner?
+  end
+end
+
+module Socialization
+  module Mentioner
+    extend ActiveSupport::Concern
+
+    included do
+      after_destroy { Socialization.mention_model.remove_mentionables(self) }
+
+      # Specifies if self can mention {Mentionable} objects.
+      #
+      # @return [Boolean]
+      def is_mentioner?
+        true
+      end
+      alias mentioner? is_mentioner?
+
+      # Create a new {Mention mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to be mentioned.
+      # @return [Boolean]
+      def mention!(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!"  unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.mention!(self, mentionable)
+      end
+
+      # Delete a {Mention mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to unmention.
+      # @return [Boolean]
+      def unmention!(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.unmention!(self, mentionable)
+      end
+
+      # Toggles a {Mention mention} relationship.
+      #
+      # @param [Mentionable] mentionable the object to mention/unmention.
+      # @return [Boolean]
+      def toggle_mention!(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        if mentions?(mentionable)
+          unmention!(mentionable)
+          false
+        else
+          mention!(mentionable)
+          true
+        end
+      end
+
+      # Specifies if self mentions a {Mentionable} object.
+      #
+      # @param [Mentionable] mentionable the {Mentionable} object to test against.
+      # @return [Boolean]
+      def mentions?(mentionable)
+        raise Socialization::ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.respond_to?(:is_mentionable?) && mentionable.is_mentionable?
+        Socialization.mention_model.mentions?(self, mentionable)
+      end
+
+      # Returns all the mentionables of a certain type that are mentioned by self
+      #
+      # @params [Mentionable] klass the type of {Mentionable} you want
+      # @params [Hash] opts a hash of options
+      # @return [Array<Mentionable, Numeric>] An array of Mentionable objects or IDs
+      def mentionables(klass, opts = {})
+        Socialization.mention_model.mentionables(self, klass, opts)
+      end
+      alias :mentionees :mentionables
+
+      # Returns a relation for all the mentionables of a certain type that are mentioned by self
+      #
+      # @params [Mentionable] klass the type of {Mentionable} you want
+      # @params [Hash] opts a hash of options
+      # @return ActiveRecord::Relation
+      def mentionables_relation(klass, opts = {})
+        Socialization.mention_model.mentionables_relation(self, klass, opts)
+      end
+      alias :mentionees_relation :mentionables_relation
+    end
+  end
+end

data/lib/socialization/config/config.rb

@@ -0,0 +1,39 @@
+module Socialization
+  class << self
+    def follow_model
+      if @follow_model
+        @follow_model
+      else
+        ::Follow
+      end
+    end
+
+    def follow_model=(klass)
+      @follow_model = klass
+    end
+
+    def like_model
+      if @like_model
+        @like_model
+      else
+        ::Like
+      end
+    end
+
+    def like_model=(klass)
+      @like_model = klass
+    end
+
+    def mention_model
+      if @mention_model
+        @mention_model
+      else
+        ::Mention
+      end
+    end
+
+    def mention_model=(klass)
+      @mention_model = klass
+    end
+  end
+end

data/lib/socialization/helpers/acts_as_helpers.rb

@@ -0,0 +1,39 @@
+require 'active_support/concern'
+
+module Socialization
+  module ActsAsHelpers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Make the current class a {Socialization::Follower}
+      def acts_as_follower(opts = {})
+        include Socialization::Follower
+      end
+
+      # Make the current class a {Socialization::Followable}
+      def acts_as_followable(opts = {})
+        include Socialization::Followable
+      end
+
+      # Make the current class a {Socialization::Liker}
+      def acts_as_liker(opts = {})
+        include Socialization::Liker
+      end
+
+      # Make the current class a {Socialization::Likeable}
+      def acts_as_likeable(opts = {})
+        include Socialization::Likeable
+      end
+
+      # Make the current class a {Socialization::Mentioner}
+      def acts_as_mentioner(opts = {})
+        include Socialization::Mentioner
+      end
+
+      # Make the current class a {Socialization::Mentionable}
+      def acts_as_mentionable(opts = {})
+        include Socialization::Mentionable
+      end
+    end
+  end
+end

data/lib/socialization/helpers/string.rb

@@ -0,0 +1,17 @@
+class String
+
+  def deep_const_get
+    result = nil
+    path = self.clone.split("::")
+
+    path.each do |p|
+      result = (result || Kernel).const_get(p)
+    end
+    result
+  end
+
+  def is_integer?
+    self.to_i.to_s == self
+  end
+
+end

data/lib/socialization/lib/exceptions.rb

@@ -0,0 +1,3 @@
+module Socialization
+  class ArgumentError < ::ArgumentError; end
+end

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

@@ -0,0 +1,125 @@
+module Socialization
+  module ActiveRecordStores
+    class Follow < ActiveRecord::Base
+      extend Socialization::Stores::Mixins::Base
+      extend Socialization::Stores::Mixins::Follow
+      extend Socialization::ActiveRecordStores::Mixins::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)
+      }
+
+      class << self
+        def follow!(follower, followable)
+          unless follows?(follower, followable)
+            self.create! do |follow|
+              follow.follower = follower
+              follow.followable = followable
+            end
+            update_counter(follower, followees_count: +1)
+            update_counter(followable, followers_count: +1)
+            call_after_create_hooks(follower, followable)
+            true
+          else
+            false
+          end
+        end
+
+        def unfollow!(follower, followable)
+          if follows?(follower, followable)
+            follow_for(follower, followable).destroy_all
+            update_counter(follower, followees_count: -1)
+            update_counter(followable, followers_count: -1)
+            call_after_destroy_hooks(follower, followable)
+            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.to_a
+          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.to_a
+          else
+            rel
+          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)
+        end
+      end # class << self
+
+    end
+  end
+end