mongoid_likes 0.0.1

data/.gitignore

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

data/.rbenv-gemsets

@@ -0,0 +1 @@
+mongoid_likes

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.2-p290

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm_gemset_create_on_use_flag=1
+rvm use 1.9.2@mongoid_likes

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.2

data/.watchr

@@ -0,0 +1,23 @@
+# vim:set filetype=ruby:
+def run(cmd)
+  puts cmd
+  system cmd
+end
+
+def spec(file)
+  if File.exists?(file)
+    run("rspec #{file}")
+  else
+    puts("Spec: #{file} does not exist.")
+  end
+end
+
+watch("spec/.*/*_spec\.rb") do |match|
+  puts(match[0])
+  spec(match[0])
+end
+
+watch("lib/(.*/.*)\.rb") do |match|
+  puts(match[1])
+  spec("spec/#{match[1]}_spec.rb")
+end

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+group :test do
+  gem 'rake'  
+end
+# Specify your gem's dependencies in mongoid_likes.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => ['spec']

data/Readme.md

@@ -0,0 +1,78 @@
+# Mongoid Likes
+
+mongoid_likes allows you to easily add liking ability to you Mongoid documents.
+
+[![Build Status](https://secure.travis-ci.org/stigi/mongoid_likes.png?branch=master)](http://travis-ci.org/stigi/mongoid_likes)
+
+## Installation
+
+Add the following to your Gemfile
+
+    gem 'mongoid_follow'
+
+If you like living on the edge (or if this gem isn't yet available on rubygems) you can add
+
+    gem 'mongoid_likes', :git => 'git://github.com/stigi/mongoid_likes.git', :branch => 'development'
+
+
+## Requirements
+
+This gem has been tested with [MongoID](http://mongoid.org/) version 2.4.7.
+
+
+## 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
+
+- write a proper readme
+- generate some documentation

data/app/models/mongoid_likes/like.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  class Like
+    include Mongoid::Document
+
+    field :like_type
+    field :like_id
+
+    belongs_to :liker, :polymorphic => true
+    belongs_to :liked, :polymorphic => true
+  end
+end

data/lib/mongoid_likes.rb

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

data/lib/mongoid_likes/helper.rb

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

data/lib/mongoid_likes/likeable.rb

@@ -0,0 +1,87 @@
+module Mongoid
+  module Likeable
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.field    :liked_count_field, :type => Integer, :default => 0
+      base.has_many :likers_assoc, :class_name => 'Mongoid::Like', :as => :liked, :dependent => :destroy
+    end
+
+    # know if self is liked by model
+    #
+    # Example:
+    # => @track.liker?(@joe)
+    # => true
+    def liker?(model)
+      self.likers_assoc.find(:all, conditions: {like_id: model.id}).limit(1).count > 0
+    end
+
+    # get likers count
+    # Note: this is a cache counter
+    #
+    # Example:
+    # => @track.likers_count
+    # => 1
+    def likers_count
+      self.liked_count_field
+    end
+
+    # get likers count by model
+    #
+    # Example:
+    # => @track.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:
+    # => @track.all_likers
+    # => [@joe, @max]
+    def all_likers
+      get_likers_of(self)
+    end
+
+    # view all selfs likers by model
+    #
+    # Example:
+    # => @track.all_likers_by_model
+    # => [@joe]
+    def all_likers_by_model(model)
+      get_likers_of(self, model)
+    end
+
+    # view all common likers of self against model
+    #
+    # Example:
+    # => @track.common_likers_with(@gang)
+    # => [@joe, @max]
+    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.find(like.like_id)
+      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_likes/liker.rb

@@ -0,0 +1,137 @@
+module Mongoid
+  module Liker
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.field    :likes_count_field, :type => Integer, :default => 0
+      base.has_many :likes_assoc, :class_name => 'Mongoid::Like', :as => :liker, :dependent => :destroy
+    end
+
+    # like a model
+    #
+    # Example:
+    # => @joe.like(@track)
+    def like(model)
+      if self.id != model.id && !self.likes?(model)
+
+        model.before_liked_by(self) if model.respond_to?('before_liked_by')
+        model.likers_assoc.create!(:like_type => self.class.name, :like_id => self.id)
+        model.inc(:liked_count_field, 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_field, 1)
+        self.after_like(model) if self.respond_to?('after_like')
+
+        return true
+      else
+        return false
+      end
+    end
+
+    # unlike a model
+    #
+    # Example:
+    # => @joe.unlike(@track)
+    def unlike(model)
+      if self.id != model.id && self.likes?(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')
+        model.likers_assoc.where(:like_type => self.class.name, :like_id => self.id).destroy
+        model.inc(:liked_count_field, -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_field, -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:
+    # => @joe.likes?(@tracks)
+    # => true
+    def likes?(model)
+      self.likes_assoc.find(:all, conditions: {like_id: model.id}).limit(1).count > 0
+    end
+
+    # get likes count
+    # Note: this is a cache counter
+    #
+    # Example:
+    # => @joe.likes_count
+    # => 1
+    def likes_count
+      self.likes_count_field
+    end
+
+    # get likes count by model
+    #
+    # Example:
+    # => @joe.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:
+    # => @joe.all_likes
+    # => [@track]
+    def all_likes
+      get_likes_of(self)
+    end
+
+    # view all selfs likes by model
+    #
+    # Example:
+    # => @joe.all_likes_by_model
+    # => [@track]
+    def all_likes_by_model(model)
+      get_likes_of(self, model)
+    end
+
+    # view all common likes of self against model
+    #
+    # Example:
+    # => @joe.common_likes_with(@max)
+    # => [@track1, @track2]
+    def common_likes_with(model)
+      model_likes = get_likes_of(model)
+      self_likes = get_likes_of(self)
+
+      self_likes & model_likes
+    end
+
+    private
+    def get_likes_of(me, model = nil)
+      likes = !model ? me.likes_assoc : me.likes_assoc.where(:like_type => model.to_s)
+
+      likes.collect do |like|
+        like.like_type.constantize.find(like.like_id)
+      end
+    end
+
+    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_likes/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Likes
+    VERSION = '0.0.1'
+  end
+end

data/mongoid_likes.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'mongoid_likes/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'mongoid_likes'
+  s.version     = Mongoid::Likes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Ullrich Schäfer']
+  s.email       = ['ullrich@seidbereit.de']
+  s.homepage    = 'https://github.com/stigi/mongoid_likes'
+  s.summary     = %q{Add likeing ability to Mongoid documents}
+  s.description = %q{Add liking ability to Mongoid documents. Also adds the inverse relation}
+
+  s.add_development_dependency 'rspec', '~> 2.5'
+  s.add_development_dependency 'mongoid', '~> 2.0'
+  s.add_development_dependency 'bson_ext', '~> 1.4'
+
+  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']
+end

data/spec/mongoid/models/track.rb

@@ -0,0 +1,4 @@
+class Track
+  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_likes/likes_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Mongoid::Likes do
+  describe User do
+    before :all do
+      @joe = User.create(name: 'Joe')
+      @max = User.create(name: 'Max')
+    end
+
+    it "should have no likes" do
+      [@joe, @max].each {|u| u.all_likes.should be_empty}
+    end
+
+    describe Track do
+      before :all do
+        @track1 = Track.create
+        @track2 = Track.create
+      end
+
+      it "should have no likers" do
+        [@track1, @track2].each { |t| t.all_likers.should be_empty }
+      end
+
+      it "should be likeable" do
+        @joe.like(@track1)
+      end
+
+      it "should be liked by liker" do
+        @track1.liker?(@joe).should be_true
+      end
+
+      it "should not be liked by others" do
+        @track1.liker?(@max).should_not be_true
+      end
+
+      it "should have the liker as liker" do
+        @track1.all_likers.should include @joe
+      end
+
+      it "should not have others as liker" do
+        @track1.all_likers.should_not include @max
+      end
+
+      it "should be likeable by multiple likers" do
+        @max.like(@track1)
+      end
+
+      it "should be liked by multiple likers" do
+        @track1.all_likers.should include @joe, @max
+      end
+
+      it "should have the correct likers count" do
+        @track1.likers_count.should be 2
+        @max.likes_count.should be 1
+        @joe.likes_count.should be 1
+      end
+
+      it "should be unlikable" do
+        @max.unlike(@track1)
+      end
+
+      it "should not include former liker" do
+        @track1.all_likers.should_not include @max
+      end
+
+      it "should not be included in former likes" do
+        @max.all_likes.should_not include @track1
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+
+require 'mongoid'
+models_folder = File.join(File.dirname(__FILE__), 'mongoid/models')
+Mongoid.configure do |config|
+  name = 'mongoid_likes_test'
+  host = 'localhost'
+  config.master = Mongo::Connection.new.db(name)
+  config.autocreate_indexes = true
+end
+
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app'))
+
+require 'mongoid_likes'
+require 'rspec'
+require 'rspec/autorun'
+
+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
+}

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_likes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ullrich Schäfer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: Add liking ability to Mongoid documents. Also adds the inverse relation
+email:
+- ullrich@seidbereit.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rbenv-gemsets
+- .rbenv-version
+- .rvmrc
+- .travis.yml
+- .watchr
+- Gemfile
+- Rakefile
+- Readme.md
+- app/models/mongoid_likes/like.rb
+- lib/mongoid_likes.rb
+- lib/mongoid_likes/helper.rb
+- lib/mongoid_likes/likeable.rb
+- lib/mongoid_likes/liker.rb
+- lib/mongoid_likes/version.rb
+- mongoid_likes.gemspec
+- spec/mongoid/models/track.rb
+- spec/mongoid/models/user.rb
+- spec/mongoid/mongoid_likes/likes_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/stigi/mongoid_likes
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.21
+signing_key: 
+specification_version: 3
+summary: Add likeing ability to Mongoid documents
+test_files:
+- spec/mongoid/models/track.rb
+- spec/mongoid/models/user.rb
+- spec/mongoid/mongoid_likes/likes_spec.rb
+- spec/spec_helper.rb