socialization 0.4.0 → 0.5.0.beta

data/lib/socialization/hello.rb

@@ -1,53 +0,0 @@
-require 'active_support/concern'
-
-%w{followable follower follow_store likeable liker like_store mentionable mentioner mention_store}.each do |f|
-  require "#{File.dirname(__FILE__)}/#{f}"
-end
-
-module Socialization
-  module Hello
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      ## Follow
-      def acts_as_follower(opts = nil)
-        include Socialization::Follower
-      end
-
-      def acts_as_followable(opts = nil)
-        include Socialization::Followable
-      end
-
-      def acts_as_follow_store(opts = nil)
-        include Socialization::FollowStore
-      end
-
-      ## Like
-      def acts_as_liker(opts = nil)
-        include Socialization::Liker
-      end
-
-      def acts_as_likeable(opts = nil)
-        include Socialization::Likeable
-      end
-
-      def acts_as_like_store(opts = nil)
-        include Socialization::LikeStore
-      end
-
-      ## Mention
-      def acts_as_mentioner(opts = nil)
-        include Socialization::Mentioner
-      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

data/lib/socialization/like_store.rb

@@ -1,14 +0,0 @@
-module Socialization
-  module LikeStore
-    extend ActiveSupport::Concern
-
-    included do
-      belongs_to :liker,    :polymorphic => true
-      belongs_to :likeable, :polymorphic => true
-
-      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

data/lib/socialization/likeable.rb

@@ -1,34 +0,0 @@
-module ActiveRecord
-  class Base
-    def is_likeable?
-      false
-    end
-  end
-end
-
-module Socialization
-  module Likeable
-    extend ActiveSupport::Concern
-
-    included do
-      # A liking is the Like record of the liker liking self.
-      has_many :likings, :as => :likeable, :dependent => :destroy, :class_name => 'Like'
-
-      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(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

data/lib/socialization/liker.rb

@@ -1,54 +0,0 @@
-module ActiveRecord
-  class Base
-    def is_liker?
-      false
-    end
-  end
-end
-
-module Socialization
-  module Liker
-    extend ActiveSupport::Concern
-
-    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 is_liker?
-        true
-      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 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
-
-      def likees(klass)
-        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
-        klass.joins("INNER JOIN likes ON likes.likeable_id = #{klass.to_s.tableize}.id AND likes.likeable_type = '#{klass.to_s}'").
-              where("likes.liker_type = '#{self.class.to_s}'").
-              where("likes.liker_id   =  #{self.id}")
-      end
-
-      private
-        def ensure_likeable!(likeable)
-          raise ArgumentError, "#{likeable} is not likeable!" unless likeable.is_likeable?
-        end
-    end
-  end
-end

data/lib/socialization/mention_store.rb

@@ -1,14 +0,0 @@
-module Socialization
-  module MentionStore
-    extend ActiveSupport::Concern
-
-    included do
-      belongs_to :mentioner,   :polymorphic => true
-      belongs_to :mentionable, :polymorphic => true
-
-      validates_uniqueness_of :mentionable_type, :scope => [:mentionable_id, :mentioner_type, :mentioner_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

@@ -1,36 +0,0 @@
-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 mentioner and the mentionable (self).
-      has_many :mentionings, :as => :mentionable, :dependent => :destroy, :class_name => 'Mention'
-
-      def is_mentionable?
-        true
-      end
-
-      def mentioned_by?(mentioner)
-        raise ArgumentError, "#{mentioner} is not a mentioner!" unless mentioner.is_mentioner?
-        !self.mentionings.where(:mentioner_type => mentioner.class.to_s, :mentioner_id => mentioner.id).empty?
-      end
-
-      def mentioners(klass)
-        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
-        klass.joins("INNER JOIN mentions ON mentions.mentioner_id = #{klass.to_s.tableize}.id AND mentions.mentioner_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/mentioner.rb

@@ -1,54 +0,0 @@
-module ActiveRecord
-  class Base
-    def is_mentioner?
-      false
-    end
-  end
-end
-
-module Socialization
-  module Mentioner
-    extend ActiveSupport::Concern
-
-    included do
-      # A mention is the Mention record (self) mentionning a mentionable record.
-      has_many :mentions, :as => :mentioner, :dependent => :destroy, :class_name => 'Mention'
-
-      def is_mentioner?
-        true
-      end
-
-      def mention!(mentionable)
-        ensure_mentionable!(mentionable)
-        Mention.create!({ :mentioner => self, :mentionable => mentionable }, :without_protection => true)
-      end
-
-      def unmention!(mentionable)
-        mm = mentionable.mentionings.where(:mentioner_type => self.class.to_s, :mentioner_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
-
-      def mentionees(klass)
-        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
-        klass.joins("INNER JOIN mentions ON mentions.mentionable_id = #{klass.to_s.tableize}.id AND mentions.mentionable_type = '#{klass.to_s}'").
-              where("mentions.mentioner_type = '#{self.class.to_s}'").
-              where("mentions.mentioner_id   =  #{self.id}")
-      end
-
-      private
-        def ensure_mentionable!(mentionable)
-          raise ArgumentError, "#{mentionable} is not mentionable!" unless mentionable.is_mentionable?
-        end
-
-    end
-  end
-end

data/test/follow_test.rb

@@ -1,125 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/test_helper'
-
-class FollowTest < Test::Unit::TestCase
-  context "a Follower" do
-    setup do
-      seed
-    end
-
-    should "be follower" do
-      assert_equal true, @follower1.is_follower?
-    end
-
-    should "be able to follow a Followable" do
-      assert @follower1.follow!(@followable1)
-      assert_equal true, @follower1.follows?(@followable1)
-      assert_equal false, @follower2.follows?(@followable1)
-    end
-
-    should "be able to unfollow a Followable" do
-      Follow.create :follower => @follower1, :followable => @followable1
-      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
-
-    should "expose a list of its followees" do
-      Follow.create :follower => @follower1, :followable => @followable1
-      assert @follower1.followees(ImAFollowable).is_a?(ActiveRecord::Relation)
-      assert_equal [@followable1], @follower1.followees(ImAFollowable).all
-
-      assert_equal @follower1.followees(ImAFollowable), @follower1.followees(:im_a_followables)
-      assert_equal @follower1.followees(ImAFollowable), @follower1.followees("im_a_followable")
-    end
-  end
-
-  context "a Followable" do
-    setup do
-      seed
-    end
-
-    should "be followable" do
-      assert_equal true, @followable1.is_followable?
-    end
-
-    should "be able to determine who follows it" do
-      Follow.create :follower => @follower1, :followable => @followable1
-      assert_equal true, @followable1.followed_by?(@follower1)
-      assert_equal false, @followable1.followed_by?(@follower2)
-    end
-
-    should "expose a list of its followers" do
-      Follow.create :follower => @follower1, :followable => @followable1
-      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
-      Follow.create :follower => @follower1, :followable => @followable1
-      followings = @followable1.followings
-      assert_equal 1, followings.size
-      assert followings.first.is_a?(Follow)
-    end
-  end
-
-  context "Deleting a Follower" do
-    setup do
-      seed
-      @follower1.follow!(@followable1)
-    end
-
-    should "delete its Follow records" do
-      @follower1.destroy
-      assert_equal false, @followable1.followed_by?(@follower1)
-    end
-  end
-
-  context "Deleting a Followable" do
-    setup do
-      seed
-      @follower1.follow!(@followable1)
-    end
-
-    should "delete its Follow records" do
-      @followable1.destroy
-      assert_equal false, @follower1.follows?(@followable1)
-    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
-    @followable1 = ImAFollowable.create
-    @followable2 = ImAFollowable.create
-  end
-end

data/test/like_test.rb

@@ -1,125 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/test_helper'
-
-class LikeTest < Test::Unit::TestCase
-  context "a Liker" do
-    setup do
-      seed
-    end
-
-    should "be liker" do
-      assert_equal true, @liker1.is_liker?
-    end
-
-    should "be able to like a Likeable" do
-      assert @liker1.like!(@likeable1)
-      assert_equal true, @liker1.likes?(@likeable1)
-      assert_equal false, @liker2.likes?(@likeable1)
-    end
-
-    should "be able to unlike a Likeable" do
-      Like.create :liker => @liker1, :likeable => @likeable1
-      assert @liker1.unlike!(@likeable1)
-      assert_equal false, @liker1.likes?(@likeable1)
-    end
-
-    should "not be able to like the same thing twice" do
-      assert @liker1.like!(@likeable1)
-
-      assert_raise ActiveRecord::RecordInvalid do
-        @liker1.like!(@likeable1)
-      end
-    end
-
-    should "not be able to unlike something that is not liked" do
-      assert_raise ActiveRecord::RecordNotFound do
-        @liker1.unlike!(@likeable1)
-      end
-    end
-
-    should "expose a list of its likes" do
-      Like.create :liker => @liker1, :likeable => @likeable1
-      assert @liker1.likees(ImALikeable).is_a?(ActiveRecord::Relation)
-      assert_equal [@likeable1], @liker1.likees(ImALikeable).all
-
-      assert_equal @liker1.likees(ImALikeable), @liker1.likees(:im_a_likeables)
-      assert_equal @liker1.likees(ImALikeable), @liker1.likees("im_a_likeable")
-    end
-  end
-
-  context "a Likeable" do
-    setup do
-      seed
-    end
-
-    should "be likeable" do
-      assert_equal true, @likeable1.is_likeable?
-    end
-
-    should "be able to determine who likes it" do
-      Like.create :liker => @liker1, :likeable => @likeable1
-      assert_equal true, @likeable1.liked_by?(@liker1)
-      assert_equal false, @likeable1.liked_by?(@liker2)
-    end
-
-    should "expose a list of its likers" do
-      Like.create :liker => @liker1, :likeable => @likeable1
-      assert @likeable1.likers(ImALiker).is_a?(ActiveRecord::Relation)
-      assert_equal [@liker1], @likeable1.likers(ImALiker).all
-
-      assert_equal @likeable1.likers(ImALiker), @likeable1.likers(:im_a_likers)
-      assert_equal @likeable1.likers(ImALiker), @likeable1.likers("im_a_liker")
-    end
-
-    should "expose likings" do
-      Like.create :liker => @liker1, :likeable => @likeable1
-      likings = @likeable1.likings
-      assert_equal 1, likings.size
-      assert likings.first.is_a?(Like)
-    end
-  end
-
-  context "Deleting a Liker" do
-    setup do
-      seed
-      @liker1.like!(@likeable1)
-    end
-
-    should "delete its Like records" do
-      @liker1.destroy
-      assert_equal false, @likeable1.liked_by?(@liker1)
-    end
-  end
-
-  context "Deleting a Likeable" do
-    setup do
-      seed
-      @liker1.like!(@likeable1)
-    end
-
-    should "delete its Like records" do
-      @likeable1.destroy
-      assert_equal false, @liker1.likes?(@likeable1)
-    end
-  end
-
-  context "Virgin ActiveRecord::Base objects" do
-    setup do
-      @foo = Vanilla.new
-    end
-
-    should "not be liker" do
-      assert_equal false, @foo.is_liker?
-    end
-
-    should "not be likeable" do
-      assert_equal false, @foo.is_likeable?
-    end
-  end
-
-  def seed
-    @liker1 = ImALiker.create
-    @liker2 = ImALiker.create
-    @likeable1 = ImALikeable.create
-    @likeable2 = ImALikeable.create
-  end
-end