socialization 0.2.2 → 0.3.0

data/lib/socialization/followable.rb

@@ -1,23 +1,34 @@
+module ActiveRecord
+  class Base
+    def is_followable?
+      false
+    end
+  end
+end
+
 module Socialization
   module Followable
-    def self.included(base)
-      base.class_eval do
-        # A following is the Follow record of the follower following self.
-        has_many :followings, :as => :followable, :dependent => :destroy, :class_name => 'Follow'
+    extend ActiveSupport::Concern
 
-        def is_followable?
-          true
-        end
+    included do
+      # A following is the Follow record of the follower following self.
+      has_many :followings, :as => :followable, :dependent => :destroy, :class_name => 'Follow'
 
-        def followed_by?(follower)
-          raise ArgumentError, "#{follower} is not a follower!" unless follower.respond_to?(:is_follower?) && follower.is_follower?
-          !self.followings.where(:follower_type => follower.class.to_s, :follower_id => follower.id).empty?
-        end
+      def is_followable?
+        true
+      end
+
+      def followed_by?(follower)
+        raise ArgumentError, "#{follower} is not a follower!" unless follower.is_follower?
+        !self.followings.where(:follower_type => follower.class.to_s, :follower_id => follower.id).empty?
+      end
 
-        def followers
-          self.followings.map { |f| f.follower }
-        end
+      def followers(klass)
+        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
+        klass.joins("INNER JOIN follows ON follows.follower_id = #{klass.to_s.tableize}.id AND follows.follower_type = '#{klass.to_s}'").
+              where("follows.followable_type = '#{self.class.to_s}'").
+              where("follows.followable_id   =  #{self.id}")
       end
     end
   end
-end
+end

data/lib/socialization/follower.rb

@@ -1,32 +1,43 @@
+module ActiveRecord
+  class Base
+    def is_follower?
+      false
+    end
+  end
+end
+
 module Socialization
   module Follower
-    def self.included(base)
-      base.class_eval do
-        # A follow is the Follow record of self following a followable record.
-        has_many :follows, :as => :follower, :dependent => :destroy, :class_name => 'Follow'
+    extend ActiveSupport::Concern
 
-        def is_follower?
-          true
-        end
+    included do
+      # A follow is the Follow record of self following a followable record.
+      has_many :follows, :as => :follower, :dependent => :destroy, :class_name => 'Follow'
 
-        def follow!(followable)
-          raise ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?)
-          raise ArgumentError, "#{self} cannot follow itself!" unless self != followable
-          Follow.create! :follower => self, :followable => followable
-        end
+      def is_follower?
+        true
+      end
 
-        def unfollow!(followable)
-          followable.followings.where(:follower_type => self.class.to_s, :follower_id => self.id).each do |f|
-            f.destroy
-          end
-        end
+      def follow!(followable)
+        raise ArgumentError, "#{followable} is not followable!" unless followable.is_followable?
+        raise ArgumentError, "#{self} cannot follow itself!" unless self != followable
+        Follow.create!({ :follower => self, :followable => followable }, :without_protection => true)
+      end
 
-        def follows?(followable)
-          raise ArgumentError, "#{followable} is not followable!" unless followable.respond_to?(:is_followable?) && followable.is_followable?
-          !self.follows.where(:followable_type => followable.class.to_s, :followable_id => followable.id).empty?
+      def unfollow!(followable)
+        ff = followable.followings.where(:follower_type => self.class.to_s, :follower_id => self.id)
+        unless ff.empty?
+          ff.each { |f| f.destroy }
+        else
+          raise ActiveRecord::RecordNotFound
         end
+      end
 
+      def follows?(followable)
+        raise ArgumentError, "#{followable} is not followable!" unless followable.is_followable?
+        !self.follows.where(:followable_type => followable.class.to_s, :followable_id => followable.id).empty?
       end
+
     end
   end
-end
+end

data/lib/socialization/hello.rb

@@ -1,14 +1,15 @@
-%w{followable follower follow_store likeable liker like_store}.each do |f|
+require 'active_support/concern'
+
+%w{followable follower follow_store likeable liker like_store mentionable mentionner mention_store}.each do |f|
   require "#{File.dirname(__FILE__)}/#{f}"
 end
 
 module Socialization
   module Hello
-    def self.included(klass)
-      klass.send(:extend, ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
+      ## Follow
       def acts_as_follower(opts = nil)
         include Socialization::Follower
       end
@@ -21,6 +22,7 @@ module Socialization
         include Socialization::FollowStore
       end
 
+      ## Like
       def acts_as_liker(opts = nil)
         include Socialization::Liker
       end
@@ -32,6 +34,20 @@ module Socialization
       def acts_as_like_store(opts = nil)
         include Socialization::LikeStore
       end
+
+      ## Mention
+      def acts_as_mentionner(opts = nil)
+        include Socialization::Mentionner
+      end
+
+      def acts_as_mentionable(opts = nil)
+        include Socialization::Mentionable
+      end
+
+      def acts_as_mention_store(opts = nil)
+        include Socialization::MentionStore
+      end
+
     end
   end
-end
+end

data/lib/socialization/like_store.rb

@@ -1,14 +1,14 @@
 module Socialization
   module LikeStore
-    def self.included(base)
-      base.class_eval do
-        belongs_to :liker,    :polymorphic => true
-        belongs_to :likeable, :polymorphic => true
+    extend ActiveSupport::Concern
 
-        validates_uniqueness_of :likeable_type, :scope => [:likeable_id, :liker_type, :liker_id], :message => 'You cannot like the same thing twice.'
+    included do
+      belongs_to :liker,    :polymorphic => true
+      belongs_to :likeable, :polymorphic => true
 
-        def self.human_attribute_name(*args); ''; end
-      end
+      validates_uniqueness_of :likeable_type, :scope => [:likeable_id, :liker_type, :liker_id], :message => 'You cannot like the same thing twice.'
+
+      def self.human_attribute_name(*args); ''; end
     end
   end
-end
+end

data/lib/socialization/likeable.rb

@@ -1,23 +1,34 @@
+module ActiveRecord
+  class Base
+    def is_likeable?
+      false
+    end
+  end
+end
+
 module Socialization
   module Likeable
-    def self.included(base)
-      base.class_eval do
-        # A liking is the Like record of the liker liking self.
-        has_many :likings, :as => :likeable, :dependent => :destroy, :class_name => 'Like'
+    extend ActiveSupport::Concern
 
-        def is_likeable?
-          true
-        end
+    included do
+      # A liking is the Like record of the liker liking self.
+      has_many :likings, :as => :likeable, :dependent => :destroy, :class_name => 'Like'
 
-        def liked_by?(liker)
-          raise ArgumentError, "#{liker} is not a liker!" unless liker.respond_to?(:is_liker?) && liker.is_liker?
-          !self.likings.where(:liker_type => liker.class.to_s, :liker_id => liker.id).empty?
-        end
+      def is_likeable?
+        true
+      end
+
+      def liked_by?(liker)
+        raise ArgumentError, "#{liker} is not a liker!" unless liker.is_liker?
+        !self.likings.where(:liker_type => liker.class.to_s, :liker_id => liker.id).empty?
+      end
 
-        def likers
-          self.likings.map { |l| l.liker }
-        end
+      def likers(klass)
+        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
+        klass.joins("INNER JOIN likes ON likes.liker_id = #{klass.to_s.tableize}.id AND likes.liker_type = '#{klass.to_s}'").
+              where("likes.likeable_type = '#{self.class.to_s}'").
+              where("likes.likeable_id   =  #{self.id}")
       end
     end
   end
-end
+end

data/lib/socialization/liker.rb

@@ -1,32 +1,47 @@
+module ActiveRecord
+  class Base
+    def is_liker?
+      false
+    end
+  end
+end
+
 module Socialization
   module Liker
-    def self.included(base)
-      base.class_eval do
-        # A like is the Like record of self liking a likeable record.
-        has_many :likes, :as => :liker, :dependent => :destroy, :class_name => 'Like'
+    extend ActiveSupport::Concern
 
-        def is_liker?
-          true
-        end
+    included do
+      # A like is the Like record of self liking a likeable record.
+      has_many :likes, :as => :liker, :dependent => :destroy, :class_name => 'Like'
 
-        def like!(likeable)
-          raise ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?)
-          raise ArgumentError, "#{self} cannot like itself!" unless self != likeable
-          Like.create! :liker => self, :likeable => likeable
-        end
+      def is_liker?
+        true
+      end
 
-        def unlike!(likeable)
-          likeable.likings.where(:liker_type => self.class.to_s, :liker_id => self.id).each do |l|
-            l.destroy
-          end
-        end
+      def like!(likeable)
+        ensure_likeable!(likeable)
+        raise ArgumentError, "#{self} cannot like itself!" unless self != likeable
+        Like.create!({ :liker => self, :likeable => likeable }, :without_protection => true)
+      end
 
-        def likes?(likeable)
-          raise ArgumentError, "#{likeable} is not likeable!" unless likeable.respond_to?(:is_likeable?) && likeable.is_likeable?
-          !self.likes.where(:likeable_type => likeable.class.to_s, :likeable_id => likeable.id).empty?
+      def unlike!(likeable)
+        ll = likeable.likings.where(:liker_type => self.class.to_s, :liker_id => self.id)
+        unless ll.empty?
+          ll.each { |l| l.destroy }
+        else
+          raise ActiveRecord::RecordNotFound
         end
+      end
 
+      def likes?(likeable)
+        ensure_likeable!(likeable)
+        !self.likes.where(:likeable_type => likeable.class.to_s, :likeable_id => likeable.id).empty?
       end
+
+      private
+        def ensure_likeable!(likeable)
+          raise ArgumentError, "#{likeable} is not likeable!" unless likeable.is_likeable?
+        end
     end
   end
-end
+end

data/lib/socialization/mention_store.rb

@@ -0,0 +1,14 @@
+module Socialization
+  module MentionStore
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :mentionner,   :polymorphic => true
+      belongs_to :mentionable,  :polymorphic => true
+
+      validates_uniqueness_of :mentionable_type, :scope => [:mentionable_id, :mentionner_type, :mentionner_id], :message => 'You cannot mention the same thing twice in a given object.'
+
+      def self.human_attribute_name(*args); ''; end
+    end
+  end
+end

data/lib/socialization/mentionable.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  class Base
+    def is_mentionable?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Mentionable
+    extend ActiveSupport::Concern
+
+    included do
+      # A mentioning is the Mention record of describing the mention relationship between
+      # the mentionner and the mentionable (self).
+      has_many :mentionings, :as => :mentionable, :dependent => :destroy, :class_name => 'Mention'
+
+      def is_mentionable?
+        true
+      end
+
+      def mentioned_by?(mentionner)
+        raise ArgumentError, "#{mentionner} is not a mentionner!" unless mentionner.is_mentionner?
+        !self.mentionings.where(:mentionner_type => mentionner.class.to_s, :mentionner_id => mentionner.id).empty?
+      end
+
+      def mentionners(klass)
+        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
+        klass.joins("INNER JOIN mentions ON mentions.mentionner_id = #{klass.to_s.tableize}.id AND mentions.mentionner_type = '#{klass.to_s}'").
+              where("mentions.mentionable_type = '#{self.class.to_s}'").
+              where("mentions.mentionable_id   =  #{self.id}")
+      end
+
+    end
+  end
+end

data/lib/socialization/mentionner.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  class Base
+    def is_mentionner?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Mentionner
+    extend ActiveSupport::Concern
+
+    included do
+      # A mention is the Mention record (self) mentionning a mentionable record.
+      has_many :mentions, :as => :mentionner, :dependent => :destroy, :class_name => 'Mention'
+
+      def is_mentionner?
+        true
+      end
+
+      def mention!(mentionable)
+        ensure_mentionable!(mentionable)
+        Mention.create!({ :mentionner => self, :mentionable => mentionable }, :without_protection => true)
+      end
+
+      def unmention!(mentionable)
+        mm = mentionable.mentionings.where(:mentionner_type => self.class.to_s, :mentionner_id => self.id)
+        unless mm.empty?
+          mm.each { |m| m.destroy }
+        else
+          raise ActiveRecord::RecordNotFound
+        end
+      end
+
+      def mentions?(mentionable)
+        ensure_mentionable!(mentionable)
+        !self.mentions.where(:mentionable_type => mentionable.class.to_s, :mentionable_id => mentionable.id).empty?
+      end
+
+      private
+        def ensure_mentionable!(mentionable)
+          raise ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.is_mentionable?
+        end
+
+    end
+  end
+end

data/lib/socialization/version.rb

@@ -1,3 +1,3 @@
 module Socialization
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/test/follow_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__)+'/test_helper'
+require File.expand_path(File.dirname(__FILE__))+'/test_helper'
 
 class FollowTest < Test::Unit::TestCase
   context "a Follower" do
@@ -6,8 +6,7 @@ class FollowTest < Test::Unit::TestCase
       seed
     end
 
-    should "respond to is_follower?" do
-      assert_equal true, @follower1.respond_to?(:is_follower?)
+    should "be follower" do
       assert_equal true, @follower1.is_follower?
     end
 
@@ -22,6 +21,20 @@ class FollowTest < Test::Unit::TestCase
       assert @follower1.unfollow!(@followable1)
       assert_equal false, @follower1.follows?(@followable1)
     end
+
+    should "not be able to follow the same thing twice" do
+      assert @follower1.follow!(@followable1)
+
+      assert_raise ActiveRecord::RecordInvalid do
+        @follower1.follow!(@followable1)
+      end
+    end
+
+    should "not be able to unfollow something that is not followed" do
+      assert_raise ActiveRecord::RecordNotFound do
+        @follower1.unfollow!(@followable1)
+      end
+    end
   end
 
   context "a Followable" do
@@ -29,8 +42,7 @@ class FollowTest < Test::Unit::TestCase
       seed
     end
 
-    should "respond to is_followable?" do
-      assert_equal true, @followable1.respond_to?(:is_followable?)
+    should "be followable" do
       assert_equal true, @followable1.is_followable?
     end
 
@@ -42,7 +54,11 @@ class FollowTest < Test::Unit::TestCase
 
     should "expose a list of its followers" do
       Follow.create :follower => @follower1, :followable => @followable1
-      assert_equal [@follower1], @followable1.followers
+      assert @followable1.followers(ImAFollower).is_a?(ActiveRecord::Relation)
+      assert_equal [@follower1], @followable1.followers(ImAFollower).all
+
+      assert_equal @followable1.followers(ImAFollower), @followable1.followers(:im_a_followers)
+      assert_equal @followable1.followers(ImAFollower), @followable1.followers("im_a_follower")
     end
 
     should "expose followings" do
@@ -77,6 +93,20 @@ class FollowTest < Test::Unit::TestCase
     end
   end
 
+  context "Virgin ActiveRecord::Base objects" do
+    setup do
+      @foo = Vanilla.new
+    end
+
+    should "not be follower" do
+      assert_equal false, @foo.is_follower?
+    end
+
+    should "not be followable" do
+      assert_equal false, @foo.is_followable?
+    end
+  end
+
   def seed
     @follower1 = ImAFollower.create
     @follower2 = ImAFollower.create