mongoid_socializer_actions 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+Gemfile.lock
+.bundle
+
+.DS_Store
+
+coverage
+rdoc
+pkg

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--colour
+--fail-fast

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-p125@mongoid_socializer_actions --create

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+gemspec
+
+gem "rake", "~> 10.0"
+
+group :test do
+  gem "pry-rails", "~> 0.2.2"
+  gem "rspec", "~> 2.12"
+  gem 'database_cleaner', "~> 0.9"
+end

data/Rakefile

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec]
+

data/Readme.md

@@ -0,0 +1,73 @@
+# mongoid_socializer_actions
+
+mongoid_socializer_actions allows you to easily add liking ability to you Mongoid documents.
+
+
+## Installation
+
+Add the following to your Gemfile
+
+    gem 'mongoid_socializer_actions'
+
+
+## Requirements
+
+This gem has been tested with [MongoID](http://mongoid.org/) version 3.0.21
+
+
+## Usage
+
+Mongoid Likes provides two modules that you can mix in your model objects like that:
+
+    class User
+      include Mongoid::Document
+
+      include Mongoid::Liker
+    end
+
+    class Track
+      include Mongoid::Document
+
+      include Mongoid::Likeable
+    end
+
+You can now like objects like this:
+
+    user = User.create
+    track = Track.create
+
+    user.like(track)
+
+You can query for likes like that:
+
+    track.all_likers
+    # => [user]
+
+    track.likers_count
+    # => 1
+
+    user.all_likes
+    # => [track]
+
+Also likes are polymorphic, so let's assume you have a second class `Album` that is including `Mongoid::Likeable` you can do something like this:
+
+    album = Album.create
+    user.like(album)
+    user.all_likes
+    # => [track, album]
+
+    user.all_likes_by_model(Album)
+    # => [album]
+
+    user.track_likes_count
+    # => 1
+
+    user.all_track_likes
+    # => [track]
+
+You get the idea. Have a look at the specs to see some more examples.
+
+# TODOs
+
+- Implement commentable
+- Implement sharable

data/app/models/like.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  class Like
+    include Mongoid::Document
+
+    # field :like_type
+    # field :like_id
+
+    belongs_to :liker, :class_name => 'User', :inverse_of => :likes
+    belongs_to :likable, :polymorphic => true
+  end
+end

data/lib/mongoid_socializer_actions/helper.rb

@@ -0,0 +1,5 @@
+class String
+  def camelize
+    self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end

data/lib/mongoid_socializer_actions/likeable.rb

@@ -0,0 +1,96 @@
+module Mongoid
+  module Likeable
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.field    :likers_count, :type => Integer, :default => 0
+      base.has_many :likes, :class_name => 'Mongoid::Like', :as => :likable, :dependent => :destroy do
+        def liked_by?(model_id)
+          where(liker_id: model_id).exists?
+        end
+      end
+    end
+
+    # know if self is liked by model
+    #
+    # Example:
+    # => @photo.liker?(@john)
+    # => true
+    def liker?(model)
+      self.likers_assoc.liked_by?(model.id)
+    end
+
+    def liked_by?(model)
+      self.likes.liked_by?(model.id)
+    end
+
+    # get likers count
+    # Note: this is a cache counter
+    #
+    # Example:
+    # => @photo.likers_count
+    # => 1
+    # def likers_count
+    #   self.liked_count_field
+    # end
+
+    # get likers count by model
+    #
+    # Example:
+    # => @photo.likers_count_by_model(User)
+    # => 1
+    def likers_count_by_model(model)
+      self.likers_assoc.where(:like_type => model.to_s).count
+    end
+
+    # view all selfs likers
+    #
+    # Example:
+    # => @photo.all_likers
+    # => [@john, @jashua]
+    def likers
+      ids = likes.collect{ |like| like.liker_id }
+      ids.present? ? User.find(ids) : []
+    end
+
+    # view all selfs likers by model
+    #
+    # Example:
+    # => @photo.all_likers_by_model
+    # => [@john]
+    def all_likers_by_model(model)
+      get_likers_of(self, model)
+    end
+
+    # view all common likers of self against model
+    #
+    # Example:
+    # => @photo.common_likers_with(@gang)
+    # => [@john, @jashua]
+    def common_likers_with(model)
+      model_likers = get_likers_of(model)
+      self_likers = get_likers_of(self)
+
+      self_likers & model_likers
+    end
+
+    private
+    def get_likers_of(me, model = nil)
+      likers = !model ? me.likers_assoc : me.likers_assoc.where(:like_type => model.to_s)
+
+      likers.collect do |like|
+        like.like_type.constantize.where(_id: like.like_id).first
+      end
+    end
+
+    def method_missing(missing_method, *args, &block)
+      if missing_method.to_s =~ /^(.+)_likers_count$/
+        likers_count_by_model($1.camelize)
+      elsif missing_method.to_s =~ /^all_(.+)_likers$/
+        all_likers_by_model($1.camelize)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/mongoid_socializer_actions/liker.rb

@@ -0,0 +1,144 @@
+module Mongoid
+  module Liker
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.field    :likes_count, :type => Integer, :default => 0
+      base.has_many :likes, :class_name => 'Mongoid::Like', :inverse_of => :liker, :dependent => :destroy
+    end
+
+    # like a model
+    #
+    # Example:
+    # => @john.like(@photo)
+    def like(model)
+      unless self.liked?(model)
+        model.before_liked_by(self) if model.respond_to?('before_liked_by')
+        likes << model.likes.create!
+        model.inc(:likers_count, 1)
+        model.after_liked_by(self) if model.respond_to?('after_liked_by')
+
+        self.before_like(model) if self.respond_to?('before_like')
+        # self.likes_assoc.create!(:like_type => model.class.name, :like_id => model.id)
+        self.inc(:likes_count, 1)
+        self.after_like(model) if self.respond_to?('after_like')
+        return true
+      else
+        return false
+      end
+    end
+
+    # unlike a model
+    #
+    # Example:
+    # => @john.unlike(@photo)
+    def unlike(model)
+      if self.id != model.id && self.liked?(model)
+
+        # this is necessary to handle mongodb caching on collection if unlike is following a like
+        model.reload
+        self.reload
+
+        model.before_unliked_by(self) if model.respond_to?('before_unliked_by')
+        likes.where(:likable_type => model.class.name, :likable_id => model.id).destroy
+        model.inc(:likers_count, -1)
+        model.after_unliked_by(self) if model.respond_to?('after_unliked_by')
+
+        self.before_unlike(model) if self.respond_to?('before_unlike')
+        # self.likes_assoc.where(:like_type => model.class.name, :like_id => model.id).destroy
+        self.inc(:likes_count, -1)
+        self.after_unlike(model) if self.respond_to?('after_unlike')
+
+        return true
+      else
+        return false
+      end
+    end
+
+    # know if self is already liking model
+    #
+    # Example:
+    # => @john.likes?(@photos)
+    # => true
+    def liked?(model)
+      self.likes.where(likable_id: model.id, likable_type: model.class.to_s).exists?
+    end
+
+    # get likes count
+    # Note: this is a cache counter
+    #
+    # Example:
+    # => @john.likes_count
+    # => 1
+    # def likes_count
+    #   self.likes_count_field
+    # end
+
+    # get likes count by model
+    #
+    # Example:
+    # => @john.likes_coun_by_model(User)
+    # => 1
+    def likes_count_by_model(model)
+      self.likes_assoc.where(:like_type => model.to_s).count
+    end
+
+    # view all selfs likes
+    #
+    # Example:
+    # => @john.all_likes
+    # => [@photo]
+    def liked_objects
+      get_liked_objects_of_kind
+    end
+
+    # view all selfs likes by model
+    #
+    # Example:
+    # => @john.all_likes_by_model
+    # => [@photo]
+    def get_liked_objects_of_kind(model = nil)
+      if model
+        user_likes = likes.where(likable_type: model.class.to_s)
+        extract_likes_from(user_likes, model.class.to_s)
+      else
+        likable_types = likes.map(&:likable_type).uniq
+        likable_types.collect do |likable_type|
+          user_likes = likes.select{ |like| like.likable_type == likable_type }
+          extract_likes_from(user_likes, likable_type)
+        end.flatten
+      end
+    end
+
+    def extract_likes_from(user_likes, likable_type)
+      return [] unless user_likes.present?
+      likable_ids = user_likes.map(&:likable_id)
+      likable_type.constantize.find(likable_ids)
+    end
+
+    # view all common likes of self against model
+    #
+    # Example:
+    # => @john.common_likes_with(@jashua)
+    # => [@photo1, @photo2]
+    def common_likes_with(model)
+      model_likes = get_likes_of(model)
+      self_likes = get_likes_of(self)
+
+      self_likes & model_likes
+    end
+
+    private
+
+
+    def method_missing(missing_method, *args, &block)
+      if missing_method.to_s =~ /^(.+)_likes_count$/
+        likes_count_by_model($1.camelize)
+      elsif missing_method.to_s =~ /^all_(.+)_likes$/
+        all_likes_by_model($1.camelize)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/mongoid_socializer_actions/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module MongoidSocializerActions
+    VERSION = "0.0.1"
+  end
+end

data/lib/mongoid_socializer_actions.rb

@@ -0,0 +1,4 @@
+require 'mongoid_socializer_actions/likeable'
+require 'mongoid_socializer_actions/liker'
+require 'mongoid_socializer_actions/helper'
+require 'models/like'

data/mongoid_socializer_actions.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'mongoid_socializer_actions/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'mongoid_socializer_actions'
+  s.version     = Mongoid::MongoidSocializerActions::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Sreehari B']
+  s.email       = ['sreehari@activesphere.com']
+  s.homepage    = 'https://github.com/stigi/mongoid_likes'
+  s.summary     = %q{Mongoid 3.0 add likable to objects with likers}
+  s.description = %q{Add liking ability to Mongoid documents. Qweries are performance optimized}
+
+  s.add_dependency 'mongoid', '~> 3.0'
+  s.add_dependency 'activesupport', '~> 3.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib', 'app']
+end

data/spec/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: 'mongoid_socializer_actions_test'
+      hosts:
+        - localhost:27017

data/spec/mongoid/models/photo.rb

@@ -0,0 +1,4 @@
+class Photo
+  include Mongoid::Document
+  include Mongoid::Likeable
+end

data/spec/mongoid/models/user.rb

@@ -0,0 +1,6 @@
+class User
+  include Mongoid::Document
+  include Mongoid::Liker
+
+  field :name, type: String
+end

data/spec/mongoid/mongoid_socializer_actions/likes_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Mongoid::Liker do
+  describe User do
+    before :each do
+      @john = User.create(name: 'john')
+      @jashua = User.create(name: 'jashua')
+    end
+
+    it "should have no likes" do
+      [@john, @jashua].each {|u| u.liked_objects.should be_empty}
+    end
+
+    describe Photo do
+      before :each do
+        @photo1 = Photo.create
+        @photo2 = Photo.create
+      end
+
+      it "should have no likers" do
+        [@photo1, @photo2].each { |t| t.likers.should be_empty }
+      end
+
+      it "should be likeable" do
+        expect{ @john.like(@photo1) }.to change(Mongoid::Like, :count).by(1)
+      end
+
+      it "should be liked by liker" do
+        @john.like(@photo1)
+        @photo1.liked_by?(@john).should be_true
+      end
+
+      it "should not be liked by others" do
+        @photo1.liked_by?(@jashua).should_not be_true
+      end
+
+      it "should have the liker as liker" do
+        @john.like(@photo1)
+        @photo1.likers.should include @john
+      end
+
+      it "should not have others as liker" do
+        @photo1.likers.should_not include @jashua
+      end
+
+      it "should be likeable by multiple likers" do
+        @jashua.like(@photo1).should be_true
+        @john.like(@photo1).should be_true
+      end
+
+      it "should be increase likes_count" do
+        expect{ @jashua.like(@photo1) }.to change(@jashua, :likes_count).by(1)
+      end
+
+      it "should be increase likes_count" do
+        expect{ @jashua.like(@photo1) }.to change(@photo1, :likers_count).by(1)
+      end
+
+      it "should be liked by multiple likers" do
+        @jashua.like(@photo1)
+        @john.like(@photo1)
+        @photo1.likers.should include @john, @jashua
+      end
+
+      it "should have the correct likers count" do
+        @jashua.like(@photo1)
+        @john.like(@photo1)
+        @photo1.likers_count.should be 2
+        @jashua.likes_count.should be 1
+        @john.likes_count.should be 1
+      end
+
+      it "should be unlikable" do
+        @jashua.like(@photo1)
+        @jashua.unlike(@photo1).should be_true
+      end
+
+      it "should not be unlikable by unliker" do
+        @jashua.unlike(@photo1).should be_false
+      end
+
+      it "should not include former liker" do
+        @photo1.likers.should_not include @jashua
+      end
+
+      it "should not be included in former likes" do
+        @jashua.liked_objects.should_not include @photo1
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'mongoid'
+require 'database_cleaner'
+
+models_folder = File.join(File.dirname(__FILE__), 'mongoid/models')
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app'))
+
+Mongoid.load! '/Users/sreehari/MyProjects/mongoid_likes/spec/config/mongoid.yml', :test
+
+require 'mongoid_socializer_actions'
+require 'rspec'
+require 'rspec/autorun'
+require 'pry-rails'
+
+Dir[ File.join(models_folder, '*.rb') ].each { |file|
+  require file
+  file_name = File.basename(file).sub('.rb', '')
+  klass = file_name.classify.constantize
+  klass.collection.drop
+}
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_socializer_actions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sreehari B
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &2152186160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152186160
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2152185660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152185660
+description: Add liking ability to Mongoid documents. Qweries are performance optimized
+email:
+- sreehari@activesphere.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Rakefile
+- Readme.md
+- app/models/like.rb
+- lib/mongoid_socializer_actions.rb
+- lib/mongoid_socializer_actions/helper.rb
+- lib/mongoid_socializer_actions/likeable.rb
+- lib/mongoid_socializer_actions/liker.rb
+- lib/mongoid_socializer_actions/version.rb
+- mongoid_socializer_actions.gemspec
+- spec/config/mongoid.yml
+- spec/mongoid/models/photo.rb
+- spec/mongoid/models/user.rb
+- spec/mongoid/mongoid_socializer_actions/likes_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/stigi/mongoid_likes
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- app
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Mongoid 3.0 add likable to objects with likers
+test_files:
+- spec/config/mongoid.yml
+- spec/mongoid/models/photo.rb
+- spec/mongoid/models/user.rb
+- spec/mongoid/mongoid_socializer_actions/likes_spec.rb
+- spec/spec_helper.rb