socialization 0.3.0 → 0.4.0

data/README.rdoc

@@ -69,7 +69,7 @@ Allow a model to be mentioned:
 Allow a model to mention:
   class Comment < ActiveRecord::Base
     ...
-    acts_as_mentionner
+    acts_as_mentioner
     ...
   end
 
@@ -130,9 +130,9 @@ Find out if an objects likes
 All likers
   movie.likers(User)
 
-=== acts_as_mentionner Methods
+=== acts_as_mentioner Methods
 
-<b>Note that a "mentionner" is the object containing the mention and not necessarily the actor. For example, John mentions Jane in a comment. The mentionner is the comment object, NOT John.</b>
+<b>Note that a "mentioner" is the object containing the mention and not necessarily the actor. For example, John mentions Jane in a comment. The mentioner is the comment object, NOT John.</b>
 
 Mention something
   comment.mention!(user)
@@ -150,8 +150,8 @@ Mentions?
 Find out if an objects mentions
   user.mentioned_by?(comment)
 
-All mentionners
-  user.mentionners(Comment)
+All mentioners
+  user.mentioners(Comment)
 
 ---
 

data/demo/demo_app/Gemfile

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
 gem 'rails', '~> 3.2.1'
-gem 'socialization', :git => "git://github.com/cmer/socialization.git", :branch => "mentions"
+gem 'socialization'
 # Bundle edge Rails instead:
 # gem 'rails', :git => 'git://github.com/rails/rails.git'
 

data/demo/demo_app/app/models/comment.rb

@@ -1,5 +1,5 @@
 class Comment < ActiveRecord::Base
-  acts_as_mentionner
+  acts_as_mentioner
   belongs_to :user
   belongs_to :movie
 end

data/demo/demo_app/db/migrate/20120221200644_create_mentions.rb

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

data/demo/demo_app/db/schema.rb

@@ -48,15 +48,15 @@ ActiveRecord::Schema.define(:version => 20120221202703) do
   add_index "likes", ["liker_id", "liker_type"], :name => "fk_likes"
 
   create_table "mentions", :force => true do |t|
-    t.string   "mentionner_type"
-    t.integer  "mentionner_id"
+    t.string   "mentioner_type"
+    t.integer  "mentioner_id"
     t.string   "mentionable_type"
     t.integer  "mentionable_id"
     t.datetime "created_at"
   end
 
   add_index "mentions", ["mentionable_id", "mentionable_type"], :name => "fk_mentionables"
-  add_index "mentions", ["mentionner_id", "mentionner_type"], :name => "fk_mentions"
+  add_index "mentions", ["mentioner_id", "mentioner_type"], :name => "fk_mentions"
 
   create_table "movies", :force => true do |t|
     t.string   "name"

data/generators/socialization/templates/migration_mentions.rb

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

data/lib/socialization/follower.rb

@@ -38,6 +38,13 @@ module Socialization
         !self.follows.where(:followable_type => followable.class.to_s, :followable_id => followable.id).empty?
       end
 
+      def followees(klass)
+        klass = klass.to_s.singularize.camelize.constantize unless klass.is_a?(Class)
+        klass.joins("INNER JOIN follows ON follows.followable_id = #{klass.to_s.tableize}.id AND follows.followable_type = '#{klass.to_s}'").
+              where("follows.follower_type = '#{self.class.to_s}'").
+              where("follows.follower_id   =  #{self.id}")
+
+      end
     end
   end
 end

data/lib/socialization/hello.rb

@@ -1,6 +1,6 @@
 require 'active_support/concern'
 
-%w{followable follower follow_store likeable liker like_store mentionable mentionner mention_store}.each do |f|
+%w{followable follower follow_store likeable liker like_store mentionable mentioner mention_store}.each do |f|
   require "#{File.dirname(__FILE__)}/#{f}"
 end
 
@@ -36,8 +36,8 @@ module Socialization
       end
 
       ## Mention
-      def acts_as_mentionner(opts = nil)
-        include Socialization::Mentionner
+      def acts_as_mentioner(opts = nil)
+        include Socialization::Mentioner
       end
 
       def acts_as_mentionable(opts = nil)

data/lib/socialization/liker.rb

@@ -38,6 +38,13 @@ module Socialization
         !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?

data/lib/socialization/mention_store.rb

@@ -3,10 +3,10 @@ module Socialization
     extend ActiveSupport::Concern
 
     included do
-      belongs_to :mentionner,   :polymorphic => true
-      belongs_to :mentionable,  :polymorphic => true
+      belongs_to :mentioner,   :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.'
+      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

data/lib/socialization/mentionable.rb

@@ -12,21 +12,21 @@ module Socialization
 
     included do
       # A mentioning is the Mention record of describing the mention relationship between
-      # the mentionner and the mentionable (self).
+      # the mentioner 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?
+      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 mentionners(klass)
+      def mentioners(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}'").
+        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

data/lib/socialization/{mentionner.rb → mentioner.rb}

@@ -1,30 +1,30 @@
 module ActiveRecord
   class Base
-    def is_mentionner?
+    def is_mentioner?
       false
     end
   end
 end
 
 module Socialization
-  module Mentionner
+  module Mentioner
     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'
+      has_many :mentions, :as => :mentioner, :dependent => :destroy, :class_name => 'Mention'
 
-      def is_mentionner?
+      def is_mentioner?
         true
       end
 
       def mention!(mentionable)
         ensure_mentionable!(mentionable)
-        Mention.create!({ :mentionner => self, :mentionable => mentionable }, :without_protection => true)
+        Mention.create!({ :mentioner => self, :mentionable => mentionable }, :without_protection => true)
       end
 
       def unmention!(mentionable)
-        mm = mentionable.mentionings.where(:mentionner_type => self.class.to_s, :mentionner_id => self.id)
+        mm = mentionable.mentionings.where(:mentioner_type => self.class.to_s, :mentioner_id => self.id)
         unless mm.empty?
           mm.each { |m| m.destroy }
         else
@@ -37,6 +37,13 @@ module Socialization
         !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?
@@ -44,4 +51,4 @@ module Socialization
 
     end
   end
-end
+end

data/lib/socialization/version.rb

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

data/test/follow_test.rb

@@ -35,6 +35,15 @@ class FollowTest < Test::Unit::TestCase
         @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
@@ -113,4 +122,4 @@ class FollowTest < Test::Unit::TestCase
     @followable1 = ImAFollowable.create
     @followable2 = ImAFollowable.create
   end
-end
+end

data/test/like_test.rb

@@ -35,6 +35,15 @@ class LikeTest < Test::Unit::TestCase
         @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

data/test/mention_test.rb

@@ -1,43 +1,52 @@
 require File.expand_path(File.dirname(__FILE__))+'/test_helper'
 
 class MentionTest < Test::Unit::TestCase
-  context "a Mentionner" do
+  context "a Mentioner" do
     setup do
       seed
     end
 
-    should "be mentionner" do
-      assert_equal true, @mentionner1.is_mentionner?
+    should "be mentioner" do
+      assert_equal true, @mentioner1.is_mentioner?
     end
 
     should "be able to mention a Mentionable" do
-      assert @mentionner1.mention!(@mentionable1)
-      assert_equal true, @mentionner1.mentions?(@mentionable1)
-      assert_equal false, @mentionner2.mentions?(@mentionable1)
+      assert @mentioner1.mention!(@mentionable1)
+      assert_equal true, @mentioner1.mentions?(@mentionable1)
+      assert_equal false, @mentioner2.mentions?(@mentionable1)
     end
 
     should "be able to unmention a Mentionable" do
-      Mention.create :mentionner => @mentionner1, :mentionable => @mentionable1
-      assert @mentionner1.unmention!(@mentionable1)
-      assert_equal false, @mentionner1.mentions?(@mentionable1)
+      Mention.create :mentioner => @mentioner1, :mentionable => @mentionable1
+      assert @mentioner1.unmention!(@mentionable1)
+      assert_equal false, @mentioner1.mentions?(@mentionable1)
     end
 
     should "not be able to mention the same thing twice" do
-      assert @mentionner1.mention!(@mentionable1)
+      assert @mentioner1.mention!(@mentionable1)
 
       assert_raise ActiveRecord::RecordInvalid do
-        @mentionner1.mention!(@mentionable1)
+        @mentioner1.mention!(@mentionable1)
       end
     end
 
     should "not be able to unmention something that is not mentionned" do
       assert_raise ActiveRecord::RecordNotFound do
-        @mentionner1.unmention!(@mentionable1)
+        @mentioner1.unmention!(@mentionable1)
       end
     end
 
     should "be able to mention itself" do
-      @mentionner_and_mentionable.mention!(@mentionner_and_mentionable)
+      @mentioner_and_mentionable.mention!(@mentioner_and_mentionable)
+    end
+
+    should "expose a list of its mentionees" do
+      Mention.create :mentioner => @mentioner1, :mentionable => @mentionable1
+      assert @mentioner1.mentionees(ImAMentioner).is_a?(ActiveRecord::Relation)
+      assert_equal [@mentionable1], @mentioner1.mentionees(ImAMentionable).all
+
+      assert_equal @mentioner1.mentionees(ImAMentionable), @mentioner1.mentionees(:im_a_mentionables)
+      assert_equal @mentioner1.mentionees(ImAMentionable), @mentioner1.mentionees("im_a_mentionable")
     end
   end
 
@@ -51,57 +60,57 @@ class MentionTest < Test::Unit::TestCase
     end
 
     should "be able to determine who mentions it" do
-      Mention.create :mentionner => @mentionner1, :mentionable => @mentionable1
-      assert_equal true, @mentionable1.mentioned_by?(@mentionner1)
-      assert_equal false, @mentionable1.mentioned_by?(@mentionner2)
+      Mention.create :mentioner => @mentioner1, :mentionable => @mentionable1
+      assert_equal true, @mentionable1.mentioned_by?(@mentioner1)
+      assert_equal false, @mentionable1.mentioned_by?(@mentioner2)
     end
 
-    should "expose a list of its mentionners" do
-      Mention.create :mentionner => @mentionner1, :mentionable => @mentionable1
-      assert @mentionable1.mentionners(ImAMentionner).is_a?(ActiveRecord::Relation)
-      assert_equal [@mentionner1], @mentionable1.mentionners(ImAMentionner).all
+    should "expose a list of its mentioners" do
+      Mention.create :mentioner => @mentioner1, :mentionable => @mentionable1
+      assert @mentionable1.mentioners(ImAMentioner).is_a?(ActiveRecord::Relation)
+      assert_equal [@mentioner1], @mentionable1.mentioners(ImAMentioner).all
 
-      assert_equal @mentionable1.mentionners(ImAMentionner), @mentionable1.mentionners(:im_a_mentionners)
-      assert_equal @mentionable1.mentionners(ImAMentionner), @mentionable1.mentionners("im_a_mentionner")
+      assert_equal @mentionable1.mentioners(ImAMentioner), @mentionable1.mentioners(:im_a_mentioners)
+      assert_equal @mentionable1.mentioners(ImAMentioner), @mentionable1.mentioners("im_a_mentioner")
     end
 
     should "expose mentionings" do
-      Mention.create :mentionner => @mentionner1, :mentionable => @mentionable1
+      Mention.create :mentioner => @mentioner1, :mentionable => @mentionable1
       mentionings = @mentionable1.mentionings
       assert_equal 1, mentionings.size
       assert mentionings.first.is_a?(Mention)
     end
   end
 
-  context "Deleting a mentionner" do
+  context "Deleting a mentioner" do
     setup do
       seed
-      @mentionner1.mention!(@mentionable1)
+      @mentioner1.mention!(@mentionable1)
     end
 
     should "delete its Mention records" do
-      @mentionner1.destroy
-      assert_equal false, @mentionable1.mentioned_by?(@mentionner1)
+      @mentioner1.destroy
+      assert_equal false, @mentionable1.mentioned_by?(@mentioner1)
     end
   end
 
   context "Deleting a Mentionable" do
     setup do
       seed
-      @mentionner1.mention!(@mentionable1)
+      @mentioner1.mention!(@mentionable1)
     end
 
     should "delete its Mention records" do
       @mentionable1.destroy
-      assert_equal false, @mentionner1.mentions?(@mentionable1)
+      assert_equal false, @mentioner1.mentions?(@mentionable1)
     end
   end
 
   def seed
-    @mentionner1 = ImAMentionner.create
-    @mentionner2 = ImAMentionner.create
+    @mentioner1 = ImAMentioner.create
+    @mentioner2 = ImAMentioner.create
     @mentionable1 = ImAMentionable.create
     @mentionable2 = ImAMentionable.create
-    @mentionner_and_mentionable = ImAMentionnerAndMentionable.create
+    @mentioner_and_mentionable = ImAMentionerAndMentionable.create
   end
-end
+end

data/test/test_helper.rb

@@ -50,8 +50,8 @@ ActiveRecord::Schema.define(:version => 0) do
   end
 
   create_table :mentions do |t|
-    t.string  :mentionner_type
-    t.integer :mentionner_id
+    t.string  :mentioner_type
+    t.integer :mentioner_id
     t.string  :mentionable_type
     t.integer :mentionable_id
     t.datetime :created_at
@@ -73,7 +73,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.timestamps
   end
 
-  create_table :im_a_mentionners do |t|
+  create_table :im_a_mentioners do |t|
     t.timestamps
   end
 
@@ -81,7 +81,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.timestamps
   end
 
-  create_table :im_a_mentionner_and_mentionables do |t|
+  create_table :im_a_mentioner_and_mentionables do |t|
     t.timestamps
   end
 
@@ -106,7 +106,7 @@ class User < ActiveRecord::Base
 end
 
 class Comment < ActiveRecord::Base
-  acts_as_mentionner
+  acts_as_mentioner
   belongs_to :user
   belongs_to :movie
 end
@@ -144,16 +144,16 @@ class ImALikeable < ActiveRecord::Base
   acts_as_likeable
 end
 
-class ImAMentionner < ActiveRecord::Base
-  acts_as_mentionner
+class ImAMentioner < ActiveRecord::Base
+  acts_as_mentioner
 end
 
 class ImAMentionable < ActiveRecord::Base
   acts_as_mentionable
 end
 
-class ImAMentionnerAndMentionable < ActiveRecord::Base
-  acts_as_mentionner
+class ImAMentionerAndMentionable < ActiveRecord::Base
+  acts_as_mentioner
   acts_as_mentionable
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: socialization
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-22 00:00:00.000000000 Z
+date: 2012-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70124582578560 !ruby/object:Gem::Requirement
+  requirement: &70105380527140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70124582578560
+  version_requirements: *70105380527140
 - !ruby/object:Gem::Dependency
   name: appraisal
-  requirement: &70124582578140 !ruby/object:Gem::Requirement
+  requirement: &70105380526160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70124582578140
+  version_requirements: *70105380526160
 - !ruby/object:Gem::Dependency
   name: logger
-  requirement: &70124582577720 !ruby/object:Gem::Requirement
+  requirement: &70105380525500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70124582577720
+  version_requirements: *70105380525500
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70124582577300 !ruby/object:Gem::Requirement
+  requirement: &70105380525080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70124582577300
+  version_requirements: *70105380525080
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70124582576880 !ruby/object:Gem::Requirement
+  requirement: &70105380524440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70124582576880
+  version_requirements: *70105380524440
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70124582576460 !ruby/object:Gem::Requirement
+  requirement: &70105380523500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70124582576460
+  version_requirements: *70105380523500
 description: Socialization allows any model to Follow and/or Like any other model.
   This is accomplished through a double polymorphic relationship on the Follow and
   Like models. But you don't need to know that since all the complexity is hidden
@@ -189,7 +189,7 @@ files:
 - lib/socialization/liker.rb
 - lib/socialization/mention_store.rb
 - lib/socialization/mentionable.rb
-- lib/socialization/mentionner.rb
+- lib/socialization/mentioner.rb
 - lib/socialization/version.rb
 - socialization.gemspec
 - test/follow_test.rb