socialization 0.4.0 → 0.5.0.beta

data/lib/socialization/victims/mentionable.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  class Base
+    def is_mentionable?
+      false
+    end
+  end
+end
+
+module Socialization
+  module Mentionable
+    extend ActiveSupport::Concern
+
+    included do
+      # Specifies if self can be mentioned.
+      #
+      # @return [Boolean]
+      def is_mentionable?
+        true
+      end
+
+      # Specifies if self is mentioned by a {Mentioner} object.
+      #
+      # @return [Boolean]
+      def mentioned_by?(mentioner)
+        raise ArgumentError, "#{mentioner} is not mentioner!"  unless mentioner.respond_to?(:is_mentioner?) && mentioner.is_mentioner?
+        Socialization.mention_model.mentions?(mentioner, self)
+      end
+
+      # Returns a scope of the {Mentioner}s mentioning self.
+      #
+      # @param [Class] klass the {Mentioner} class to be included in the scope. e.g. `User`.
+      # @return [Array<Mentioner, Numeric>] An array of Mentioner objects or IDs
+      def mentioners(klass, opts = {})
+        Socialization.mention_model.mentioners(self, klass, opts)
+      end
+    end
+  end
+end

data/socialization.gemspec

@@ -16,9 +16,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README.rdoc"]
-  s.rdoc_options = ["--charset=UTF-8"]
+  s.has_rdoc = false
 
   s.add_runtime_dependency "activerecord"
 
@@ -27,4 +25,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "mocha"
   s.add_development_dependency "shoulda"
   s.add_development_dependency "sqlite3"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "mock_redis"
 end

data/test/actors/follower_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
+
+class FollowerTest < Test::Unit::TestCase
+  context "Follower" do
+    setup do
+      @follower = ImAFollower.new
+      @followable = ImAFollowable.create
+    end
+
+    context "#is_follower" do
+      should "return true" do
+        assert_true @follower.is_follower?
+      end
+    end
+
+    context "#follow!" do
+      should "not accept non-followables" do
+        assert_raise(ArgumentError) { @follower.follow!(:foo) }
+      end
+
+      should "call $Follow.follow!" do
+        $Follow.expects(:follow!).with(@follower, @followable).once
+        @follower.follow!(@followable)
+      end
+    end
+
+    context "#unfollow!" do
+      should "not accept non-followables" do
+        assert_raise(ArgumentError) { @follower.unfollow!(:foo) }
+      end
+
+      should "call $Follow.follow!" do
+        $Follow.expects(:unfollow!).with(@follower, @followable).once
+        @follower.unfollow!(@followable)
+      end
+    end
+
+    context "#toggle_follow!" do
+      should "not accept non-followables" do
+        assert_raise(ArgumentError) { @follower.unfollow!(:foo) }
+      end
+
+      should "unfollow when following" do
+        @follower.expects(:follows?).with(@followable).once.returns(true)
+        @follower.expects(:unfollow!).with(@followable).once
+        @follower.toggle_follow!(@followable)
+      end
+
+      should "follow when not following" do
+        @follower.expects(:follows?).with(@followable).once.returns(false)
+        @follower.expects(:follow!).with(@followable).once
+        @follower.toggle_follow!(@followable)
+      end
+    end
+
+    context "#follows?" do
+      should "not accept non-followables" do
+        assert_raise(ArgumentError) { @follower.unfollow!(:foo) }
+      end
+
+      should "call $Follow.follows?" do
+        $Follow.expects(:follows?).with(@follower, @followable).once
+        @follower.follows?(@followable)
+      end
+    end
+
+    context "#followables" do
+      should "call $Follow.followables" do
+        $Follow.expects(:followables).with(@follower, @followable.class, { :foo => :bar })
+        @follower.followables(@followable.class, { :foo => :bar })
+      end
+    end
+  end
+end

data/test/actors/liker_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
+
+class LikerTest < Test::Unit::TestCase
+  context "Liker" do
+    setup do
+      @liker = ImALiker.new
+      @likeable = ImALikeable.create
+    end
+
+    context "#is_liker" do
+      should "return true" do
+        assert_true @liker.is_liker?
+      end
+    end
+
+    context "#like!" do
+      should "not accept non-likeables" do
+        assert_raise(ArgumentError) { @liker.like!(:foo) }
+      end
+
+      should "call $Like.like!" do
+        $Like.expects(:like!).with(@liker, @likeable).once
+        @liker.like!(@likeable)
+      end
+    end
+
+    context "#unlike!" do
+      should "not accept non-likeables" do
+        assert_raise(ArgumentError) { @liker.unlike!(:foo) }
+      end
+
+      should "call $Like.like!" do
+        $Like.expects(:unlike!).with(@liker, @likeable).once
+        @liker.unlike!(@likeable)
+      end
+    end
+
+    context "#toggle_like!" do
+      should "not accept non-likeables" do
+        assert_raise(ArgumentError) { @liker.unlike!(:foo) }
+      end
+
+      should "unlike when likeing" do
+        @liker.expects(:likes?).with(@likeable).once.returns(true)
+        @liker.expects(:unlike!).with(@likeable).once
+        @liker.toggle_like!(@likeable)
+      end
+
+      should "like when not likeing" do
+        @liker.expects(:likes?).with(@likeable).once.returns(false)
+        @liker.expects(:like!).with(@likeable).once
+        @liker.toggle_like!(@likeable)
+      end
+    end
+
+    context "#likes?" do
+      should "not accept non-likeables" do
+        assert_raise(ArgumentError) { @liker.unlike!(:foo) }
+      end
+
+      should "call $Like.likes?" do
+        $Like.expects(:likes?).with(@liker, @likeable).once
+        @liker.likes?(@likeable)
+      end
+    end
+
+    context "#likeables" do
+      should "call $Like.likeables" do
+        $Like.expects(:likeables).with(@liker, @likeable.class, { :foo => :bar })
+        @liker.likeables(@likeable.class, { :foo => :bar })
+      end
+    end
+  end
+end

data/test/actors/mentioner_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
+
+class MentionerTest < Test::Unit::TestCase
+  context "Mentioner" do
+    setup do
+      @mentioner = ImAMentioner.new
+      @mentionable = ImAMentionable.create
+    end
+
+    context "#is_mentioner" do
+      should "return true" do
+        assert_true @mentioner.is_mentioner?
+      end
+    end
+
+    context "#mention!" do
+      should "not accept non-mentionables" do
+        assert_raise(ArgumentError) { @mentioner.mention!(:foo) }
+      end
+
+      should "call $Mention.mention!" do
+        $Mention.expects(:mention!).with(@mentioner, @mentionable).once
+        @mentioner.mention!(@mentionable)
+      end
+    end
+
+    context "#unmention!" do
+      should "not accept non-mentionables" do
+        assert_raise(ArgumentError) { @mentioner.unmention!(:foo) }
+      end
+
+      should "call $Mention.mention!" do
+        $Mention.expects(:unmention!).with(@mentioner, @mentionable).once
+        @mentioner.unmention!(@mentionable)
+      end
+    end
+
+    context "#toggle_mention!" do
+      should "not accept non-mentionables" do
+        assert_raise(ArgumentError) { @mentioner.unmention!(:foo) }
+      end
+
+      should "unmention when mentioning" do
+        @mentioner.expects(:mentions?).with(@mentionable).once.returns(true)
+        @mentioner.expects(:unmention!).with(@mentionable).once
+        @mentioner.toggle_mention!(@mentionable)
+      end
+
+      should "mention when not mentioning" do
+        @mentioner.expects(:mentions?).with(@mentionable).once.returns(false)
+        @mentioner.expects(:mention!).with(@mentionable).once
+        @mentioner.toggle_mention!(@mentionable)
+      end
+    end
+
+    context "#mentions?" do
+      should "not accept non-mentionables" do
+        assert_raise(ArgumentError) { @mentioner.unmention!(:foo) }
+      end
+
+      should "call $Mention.mentions?" do
+        $Mention.expects(:mentions?).with(@mentioner, @mentionable).once
+        @mentioner.mentions?(@mentionable)
+      end
+    end
+
+    context "#mentionables" do
+      should "call $Mention.mentionables" do
+        $Mention.expects(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
+        @mentioner.mentionables(@mentionable.class, { :foo => :bar })
+      end
+    end
+  end
+end

data/test/stores/active_record/follow_store_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class ActiveRecordFollowStoreTest < Test::Unit::TestCase
+  context "ActiveRecordStores::FollowStoreTest" do
+    setup do
+      @klass = Socialization::ActiveRecordStores::FollowStore
+      @klass.touch nil
+      @klass.after_follow nil
+      @klass.after_unfollow nil
+      @follower = ImAFollower.create
+      @followable = ImAFollowable.create
+    end
+
+    context "data store" do
+      should "inherit Socialization::ActiveRecordStores::FollowStore" do
+        assert_equal Socialization::ActiveRecordStores::FollowStore, Socialization.follow_model
+      end
+    end
+
+    context "#follow!" do
+      should "create a Follow record" do
+        @klass.follow!(@follower, @followable)
+        assert_match_follower @klass.last, @follower
+        assert_match_followable @klass.last, @followable
+      end
+
+      should "touch follower when instructed" do
+        @klass.touch :follower
+        @follower.expects(:touch).once
+        @followable.expects(:touch).never
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "touch followable when instructed" do
+        @klass.touch :followable
+        @follower.expects(:touch).never
+        @followable.expects(:touch).once
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "touch all when instructed" do
+        @klass.touch :all
+        @follower.expects(:touch).once
+        @followable.expects(:touch).once
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "call after follow hook" do
+        @klass.after_follow :after_follow
+        @klass.expects(:after_follow).once
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "call after unfollow hook" do
+        @klass.after_follow :after_unfollow
+        @klass.expects(:after_unfollow).once
+        @klass.follow!(@follower, @followable)
+      end
+    end
+
+    context "#follows?" do
+      should "return true when follow exists" do
+        @klass.create! do |f|
+          f.follower = @follower
+          f.followable = @followable
+        end
+        assert_true @klass.follows?(@follower, @followable)
+      end
+
+      should "return false when follow doesn't exist" do
+        assert_false @klass.follows?(@follower, @followable)
+      end
+    end
+
+    context "#followers" do
+      should "return an array of followers" do
+        follower1 = ImAFollower.create
+        follower2 = ImAFollower.create
+        follower1.follow!(@followable)
+        follower2.follow!(@followable)
+        assert_equal [follower1, follower2], @klass.followers(@followable, follower1.class)
+      end
+
+      should "return an array of follower ids when plucking" do
+        follower1 = ImAFollower.create
+        follower2 = ImAFollower.create
+        follower1.follow!(@followable)
+        follower2.follow!(@followable)
+        assert_equal [follower1.id, follower2.id], @klass.followers(@followable, follower1.class, :pluck => :id)
+      end
+    end
+
+    context "#followables" do
+      should "return an array of followers" do
+        followable1 = ImAFollowable.create
+        followable2 = ImAFollowable.create
+        @follower.follow!(followable1)
+        @follower.follow!(followable2)
+        assert_equal [followable1, followable2], @klass.followables(@follower, followable1.class)
+      end
+
+      should "return an array of follower ids when plucking" do
+        followable1 = ImAFollowable.create
+        followable2 = ImAFollowable.create
+        @follower.follow!(followable1)
+        @follower.follow!(followable2)
+        assert_equal [followable1.id, followable2.id], @klass.followables(@follower, followable1.class, :pluck => :id)
+      end
+    end
+
+  end
+
+  # Helpers
+  def assert_match_follower(follow_record, follower)
+    assert follow_record.follower_type ==  follower.class.to_s && follow_record.follower_id == follower.id
+  end
+
+  def assert_match_followable(follow_record, followable)
+    assert follow_record.followable_type ==  followable.class.to_s && follow_record.followable_id == followable.id
+  end
+end

data/test/stores/active_record/like_store_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class ActiveRecordLikeStoreTest < Test::Unit::TestCase
+  context "ActiveRecordStore::LikeStoreTest" do
+    setup do
+      @klass = Socialization::ActiveRecordStores::LikeStore
+      @klass.touch nil
+      @klass.after_like nil
+      @klass.after_unlike nil
+      @liker = ImALiker.create
+      @likeable = ImALikeable.create
+    end
+
+    context "data store" do
+      should "inherit Socialization::ActiveRecordStores::LikeStore" do
+        assert_equal Socialization::ActiveRecordStores::LikeStore, Socialization.like_model
+      end
+    end
+
+    context "#like!" do
+      should "create a Like record" do
+        @klass.like!(@liker, @likeable)
+        assert_match_liker @klass.last, @liker
+        assert_match_likeable @klass.last, @likeable
+      end
+
+      should "touch liker when instructed" do
+        @klass.touch :liker
+        @liker.expects(:touch).once
+        @likeable.expects(:touch).never
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "touch likeable when instructed" do
+        @klass.touch :likeable
+        @liker.expects(:touch).never
+        @likeable.expects(:touch).once
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "touch all when instructed" do
+        @klass.touch :all
+        @liker.expects(:touch).once
+        @likeable.expects(:touch).once
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "call after like hook" do
+        @klass.after_like :after_like
+        @klass.expects(:after_like).once
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "call after unlike hook" do
+        @klass.after_like :after_unlike
+        @klass.expects(:after_unlike).once
+        @klass.like!(@liker, @likeable)
+      end
+    end
+
+    context "#likes?" do
+      should "return true when like exists" do
+        @klass.create! do |f|
+          f.liker = @liker
+          f.likeable = @likeable
+        end
+        assert_true @klass.likes?(@liker, @likeable)
+      end
+
+      should "return false when like doesn't exist" do
+        assert_false @klass.likes?(@liker, @likeable)
+      end
+    end
+
+    context "#likers" do
+      should "return an array of likers" do
+        liker1 = ImALiker.create
+        liker2 = ImALiker.create
+        liker1.like!(@likeable)
+        liker2.like!(@likeable)
+        assert_equal [liker1, liker2], @klass.likers(@likeable, liker1.class)
+      end
+
+      should "return an array of liker ids when plucking" do
+        liker1 = ImALiker.create
+        liker2 = ImALiker.create
+        liker1.like!(@likeable)
+        liker2.like!(@likeable)
+        assert_equal [liker1.id, liker2.id], @klass.likers(@likeable, liker1.class, :pluck => :id)
+      end
+    end
+
+    context "#likeables" do
+      should "return an array of likers" do
+        likeable1 = ImALikeable.create
+        likeable2 = ImALikeable.create
+        @liker.like!(likeable1)
+        @liker.like!(likeable2)
+        assert_equal [likeable1, likeable2], @klass.likeables(@liker, likeable1.class)
+      end
+
+      should "return an array of liker ids when plucking" do
+        likeable1 = ImALikeable.create
+        likeable2 = ImALikeable.create
+        @liker.like!(likeable1)
+        @liker.like!(likeable2)
+        assert_equal [likeable1.id, likeable2.id], @klass.likeables(@liker, likeable1.class, :pluck => :id)
+      end
+    end
+
+  end
+
+  # Helpers
+  def assert_match_liker(like_record, liker)
+    assert like_record.liker_type ==  liker.class.to_s && like_record.liker_id == liker.id
+  end
+
+  def assert_match_likeable(like_record, likeable)
+    assert like_record.likeable_type ==  likeable.class.to_s && like_record.likeable_id == likeable.id
+  end
+end