mongoid-doable 0.1.0

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 aproxacs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# mongoid-doable
+
+While I was working with rails and mongoid, the functions like below was necessary.
+  
+    user.like(comment)
+    user.bookmark(course)
+    user.register(course)
+    user.follow(another_user)
+
+While implementing these functions, I found that they all do the same thing in the model, they just have a different expression. So the mongoid-doable came out.
+
+
+# Installation
+#### Using Gem
+  
+    gem install mongoid-doable
+
+#### Using bundler
+  
+    gem 'mongoid-doable'
+
+
+# Examples
+
+    class Course
+      include Monogid::Document
+      include Monogid::Doable
+      doable :like, by: :user
+    end
+    class User
+      include Monogid::Document
+      include Monogid::Doable
+      doer :like, :course
+    end
+
+    user = User.create
+    course = Course.create
+
+    user.like!(course) # or
+    user.like_course!(course) # or
+    course.liked_by!(user) # or
+
+    user.liking_courses
+    user.liking_courses_count
+
+    course.likers
+    course.likers_count
+
+    
+
+# Contributing to mongoid-doable
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 aproxacs. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mongoid-doable"
+  gem.homepage = "http://github.com/aproxacs/mongoid-doable"
+  gem.license = "MIT"
+  gem.summary = %q{Able to do something like 'bookmark', 'like' or 'follow' with mongoid}
+  gem.description = %q{Able to do something like 'bookmark', 'like' or 'follow' with mongoid}
+  gem.email = "aproxacs@gmail.com"
+  gem.authors = ["aproxacs"]
+  gem.files = [
+    "Rakefile",
+    "README.md",
+    "VERSION",
+    "lib/mongoid-doable.rb",
+    "lib/mongoid/*.rb",
+    "spec/**/*.rb"
+  ]
+
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mongoid-doable #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/mongoid-doable.rb

@@ -0,0 +1,3 @@
+require "mongoid"
+require "active_support"
+require "mongoid/doable"

data/lib/mongoid/doable.rb

@@ -0,0 +1,163 @@
+module Mongoid
+  module Doable
+    extend ActiveSupport::Concern
+
+    included do |base|      
+    end
+
+    module ClassMethods
+      # Examples
+      #   class Course
+      #     include Monogid::Document
+      #     include Monogid::Doable
+      #
+      #     doable :like, by: :user
+      #   end
+      #
+      #   class User
+      #     include Monogid::Document
+      #     include Monogid::Doable
+      #
+      #     doer :like, :course
+      #
+      #     doable :follow, by: :user
+      #     doer :follow, :user
+      #   end
+      #
+      #   user = User.first
+      #   course = Course.first
+      #
+      #   user.like!(course) # or
+      #   user.like_course!(course) # or
+      #   course.liked_by!(user) # or
+      #
+      #   user.liking_courses
+      #   user.liking_courses_count
+      #
+      #   course.likers
+      #   course.likers_count
+      #
+
+      def doable(action, options = {})
+        doer_models[action.to_sym] = (options[:by] || :user).to_s.classify.constantize
+
+        action = action.to_s                                          # "like"
+        base_action = (action[-1] == "e" ? action.chop : action)      # "lik"
+        passive_action = base_action + "ed"                           # "liked"
+        doer_action = base_action + "ers"                             # "likers"
+
+        field_name = "#{doer_action}_ids"                             # "likers_ids"
+        counter_field_name = "#{doer_action}_count"                   # "likers_count"
+        field field_name, type: Array, default: [], versioned: false          # field :likers_ids, type: Array, default: [], versioned: false
+        field counter_field_name, type: Integer, default: 0, versioned: false # field :likers_count, type: Integer, default: 0, versioned: false
+
+        define_method "#{doer_action}" do                             # def likers
+          klass = self.class.doer_models[action.to_sym]               #   klass = User
+          klass.where(:"_id".in => send(field_name))                  #   klass.where(:likers_ids.in => likers_ids)
+        end                                                           # end
+
+        define_method "#{passive_action}_by?" do |actor|              # def liked_by?(actor)
+          return false if actor.blank?                                #   return false if actor.blank?
+          send(field_name).include? actor.id                          #   likers_ids.include? actor.id
+        end                                                           # end
+
+        define_method "#{passive_action}_by!" do |actor|              # def liked_by!(actor)
+          return false if actor.blank?                                #   return false if actor.blank?          
+          if actor.respond_to?("#{action}!")                          #   if actor.respond_to?(:like!)
+            actor.send("#{action}!", self)                            #     actor.like!(self) 
+          else                                                        #   else
+            add_to_set(field_name, actor.id)                          #     self.add_to_set(:liker_ids, actor.id)  
+            inc(counter_field_name.to_sym, 1)                         #     inc(:likers_count, 1)
+          end                                                         #   end          
+        end                                                           # end
+
+        define_method "un#{passive_action}_by!" do |actor|            # def unliked_by!(actor)
+          return false if actor.blank?                                #   return false if actor.blank?          
+          if actor.respond_to?("un#{action}!")                        #   if actor.respond_to?(:unlike!)
+            actor.send("un#{action}!", self)                          #     actor.unlike!(self) 
+          else                                                        #   else
+            pull(field_name, actor.id)                                #     self.pull(:liker_ids, actor.id)
+            inc(counter_field_name.to_sym, -1)                        #     inc(:likers_count, -1)
+          end                                                         #   end
+        end                                                           # end
+      end
+
+      def doer(action, target, options = {})
+
+        action = action.to_s                                                # "like"
+        base_action = (action[-1] == "e" ? action.chop : action)            # "lik"
+        ing_action = base_action + "ing"                                    # "liking"
+        passive_action = base_action + "ed"                                 # "liked"
+        doer_action = base_action + "ers"                                   # "likers"
+      
+        field_name = "#{ing_action}_#{target.to_s.pluralize}_ids"           # "liking_courses_ids"
+        target_field_name = "#{doer_action}_ids"                            # "likers_ids"
+        target_counter_name = "#{doer_action}_count"                        # "likers_count"
+        klass = (options[:class_name] || target.to_s.classify).constantize  # Course
+
+        field field_name, type: Array, default: [], versioned: false        # field :liking_courses_ids, type Array, default: [], versioned: false
+
+        define_method "#{ing_action}_#{target.to_s.pluralize}_count" do     # def liking_courses_count
+          send(field_name).size                                             #   liking_courses_ids.size
+        end                                                                 # end
+
+        unless options[:embedded]
+          define_method "#{ing_action}_#{target.to_s.pluralize}" do         # def liking_courses
+            klass.where(:"_id".in => send(field_name))           #   Course.where(:liking_courses_ids.in => liking_courses_ids)
+          end                                                               # end
+        end
+
+
+        unless method_defined? "#{ing_action}?"
+          define_method "#{ing_action}?" do |model|                         # def liking?(course)
+            field = model.class.name.split(":").last.downcase               #   
+            send("#{ing_action}_#{field}?", model)                          #   liking_course?(course)
+          end                                                               # end
+        end
+
+        define_method "#{ing_action}_#{target}?" do |model|                 # def liking_course?(course)
+          send(field_name).include?(model.id)                               #   liking_courses_ids.include?(course.id)
+        end                                                                 # end
+
+        unless method_defined? "#{action}!"
+          define_method "#{action}!" do |model|                                                   # def like!(couse)
+            field = model.class.name.split(":").last.downcase                                     #   
+            send("#{action}_#{field}!", model)                                                    #   like_course!(course)
+          end                                                                                     # end
+        end
+
+        define_method "#{action}_#{target}!" do |model|                                           # def like_course!(course)
+          return if send("#{ing_action}_#{target}?", model)                                       #   return if liking_course?(course)
+
+          model.add_to_set(target_field_name, self.id) if model.respond_to?(target_field_name)    #   course.add_to_set(:likers_ids, self.id) if model.respond_to?(:likers_ids)
+          model.inc(target_counter_name, 1)                                                       #   coruse.inc(:likers_ids, 1)
+          add_to_set(field_name, model.id)                                                        #   add_to_set(:liking_courses_ids, course.id)
+        end                                                                                       # end
+
+
+        unless method_defined? "un#{action}!"
+          define_method "un#{action}!" do |model|                                                 # def unlike!(course)
+            field = model.class.name.split(":").last.downcase                                     #   
+            send("un#{action}_#{field}!", model)                                                  #   like_course!(course)
+          end                                                                                     # end
+        end
+
+        define_method "un#{action}_#{target}!" do |model|                                         # def unlike_course!(course)
+          return unless send("#{ing_action}_#{target}?", model)                                   #   return unless liking_course?(course)
+
+          model.pull(target_field_name, self.id) if model.respond_to?(target_field_name)          #   course.pull(:likers_ids, self.id) if course.respond_to?(:likers_ids)
+          model.inc(target_counter_name, -1)                                                      #   course.inc(likers_ids, -1)
+          self.pull(field_name, model.id)                                                         #   self.pull(:liking_courses_ids)
+        end                                                                                       # end
+
+      end
+
+      def doer_models                                                   # def doer_models
+        @doer_models ||= {}                                             #   @doer_models ||= {}
+      end                                                               # end
+
+    end
+
+  end
+end
+

data/spec/mongoid/doable_spec.rb

@@ -0,0 +1,254 @@
+require "spec_helper"
+
+module Doable
+  class Course
+  end
+  class Student
+  end
+
+  class User
+    include Mongoid::Document
+    include Mongoid::Doable
+
+    doer :like, :course, class_name: "Doable::Course"
+    doer :like, :student, class_name: "Doable::Student", embedded: true
+
+    doable :follow, by: "Doable::User"
+    doer :follow, :user, class_name: "Doable::User"
+
+    doer :bookmark, :course, class_name: "Doable::Course"
+  end
+
+  class Course
+    include Mongoid::Document
+    include Mongoid::Doable
+
+    embeds_many :students
+
+    doable :like, by: "Doable::User"
+    doable :bookmark, by: "Doable::User"
+  end
+
+  class Student
+    include Mongoid::Document
+    include Mongoid::Doable
+
+    embedded_in :course
+
+    doable :like, by: "Doable::User"
+  end
+end
+
+describe "likeable" do
+  let(:user) { Doable::User.create }
+  let(:course) { Doable::Course.create }
+
+  subject { user }
+
+  context "default values" do
+    its(:liking_courses_ids) { should == [] }
+    its(:liking_courses_count) { should == 0 }
+    its(:liking_courses) { should == [] }
+    it { subject.should_not be_liking(course) }
+
+    context "with course" do
+      subject { course }
+      its(:likers_ids) { should == [] }
+      its(:likers_count) { should == 0 }
+      its(:likers) { should == [] }
+      it { subject.should_not be_liked_by(user) }
+    end
+  end
+
+  context "when a user likes course" do
+    before { user.like!(course) }
+
+    its(:liking_courses_ids) { should == [course.id] }
+    its(:liking_courses_count) { should == 1 }
+    its(:liking_courses) { should == [course] }
+    it { subject.should be_liking(course) }
+
+    context "with course" do
+      subject { course }
+      its(:likers_ids) { should == [user.id] }
+      its(:likers_count) { should == 1 }
+      its(:likers) { should == [user]}
+      it { subject.should be_liked_by(user) }
+    end
+
+    context "when the same user likes course once more" do
+      before { user.like!(course) }
+
+      its(:liking_courses_ids) { should == [course.id] }
+      its(:liking_courses_count) { should == 1 }
+    end
+
+    context "when user unlike course" do
+      before { user.unlike!(course) }
+
+      its(:liking_courses_ids) { should == [] }
+      its(:liking_courses_count) { should == 0 }
+      its(:liking_courses) { should == [] }
+      it { subject.should_not be_liking(course) }
+
+      context "with course" do
+        subject { course }
+        its(:likers_ids) { should == [] }
+        its(:likers_count) { should == 0 }
+        its(:likers) { should == [] }
+        it { subject.should_not be_liked_by(user) }
+      end
+
+    end
+  end
+
+  context "when user unlikes course" do
+    before { user.unlike!(course) }
+
+    its(:liking_courses_ids) { should == [] }
+  end
+
+
+  context "for embedded document" do
+    let(:student) { course.students.create }
+    subject { user }
+
+    its(:liking_students_count) { should == 0 }
+    it { subject.should_not be_respond_to(:liking_students) }
+
+    context "when a user likes student" do
+      before { user.like!(student) }
+
+      its(:liking_students_ids) { should == [student.id] }
+    end
+  end
+
+end
+
+
+describe "followable" do
+  let(:user) { Doable::User.create }
+  let(:user2) { Doable::User.create }
+
+  subject { user }
+
+  context "default values" do
+    its(:following_users_ids) { should == [] }
+    its(:following_users_count) { should == 0 }
+    its(:following_users) { should == [] }
+    it { subject.should_not be_following(user2) }
+    its(:followers_ids) { should == [] }
+    its(:followers_count) { should == 0 }
+    its(:followers) { should == []}
+    it { subject.should_not be_followed_by(user2)}
+  end
+
+  context "when user follows user2" do
+    before { user.follow!(user2) }
+    its(:following_users_ids) { should == [user2.id] }
+    its(:following_users_count) { should == 1 }
+    its(:following_users) { should == [user2] }
+    it { subject.should be_following(user2) }
+    its(:followers_ids) { should == [] }
+    its(:followers_count) { should == 0 }
+    its(:followers) { should == []}
+    it { subject.should_not be_followed_by(user2)}
+
+    context "with user2" do
+      subject { user2 }
+      its(:following_users_ids) { should == [] }
+      its(:following_users_count) { should == 0 }
+      its(:following_users) { should == [] }
+      it { subject.should_not be_following(user) }
+      its(:followers_ids) { should == [user.id] }
+      its(:followers_count) { should == 1 }
+      its(:followers) { should == [user]}
+      it { subject.should be_followed_by(user)}
+    end
+
+    context "when user unfollows user2" do
+      before { user.unfollow!(user2) }
+      its(:following_users_ids) { should == [] }
+      its(:following_users_count) { should == 0 }
+      its(:following_users) { should == [] }
+      it { subject.should_not be_following(user2) }
+      its(:followers_ids) { should == [] }
+      its(:followers_count) { should == 0 }
+      its(:followers) { should == []}
+      it { subject.should_not be_followed_by(user2)}
+    end
+  end
+
+end
+
+
+describe "bookmarkable" do
+  let(:user) { Doable::User.create }
+  let(:course) { Doable::Course.create }
+
+  subject { user }
+
+  context "default values" do
+    its(:bookmarking_courses_ids) { should == [] }
+    its(:bookmarking_courses_count) { should == 0 }
+    its(:bookmarking_courses) { should == [] }
+    it { subject.should_not be_bookmarking(course) }
+
+    context "with course" do
+      subject { course }
+      its(:bookmarkers_ids) { should == [] }
+      its(:bookmarkers_count) { should == 0 }
+      its(:bookmarkers) { should == [] }
+      it { subject.should_not be_bookmarked_by(user) }
+    end
+  end
+
+  context "when a user bookmarks course" do
+    before { user.bookmark_course!(course) }
+
+    its(:bookmarking_courses_ids) { should == [course.id] }
+    its(:bookmarking_courses_count) { should == 1 }
+    its(:bookmarking_courses) { should == [course] }
+    it { subject.should be_bookmarking(course) }
+
+    context "with course" do
+      subject { course }
+      its(:bookmarkers_ids) { should == [user.id] }
+      its(:bookmarkers_count) { should == 1 }
+      its(:bookmarkers) { should == [user] }
+      it { subject.should be_bookmarked_by(user) }
+    end
+
+    context "when the same user bookmarks course once more" do
+      before { user.bookmark_course!(course) }
+
+      its(:bookmarking_courses_ids) { should == [course.id] }
+      its(:bookmarking_courses_count) { should == 1 }
+    end
+
+    context "when user unbookmark course" do
+      before { user.unbookmark_course!(course) }
+
+      its(:bookmarking_courses_ids) { should == [] }
+      its(:bookmarking_courses_count) { should == 0 }
+      its(:bookmarking_courses) { should == [] }
+      it { subject.should_not be_bookmarking(course) }
+
+      context "with course" do
+        subject { course }
+        its(:bookmarkers_ids) { should == [] }
+        its(:bookmarkers_count) { should == 0 }
+        its(:bookmarkers) { should == [] }
+        it { subject.should_not be_bookmarked_by(user) }
+      end
+
+    end
+  end
+
+  context "when user unbookmarks course" do
+    before { user.unbookmark_course!(course) }
+
+    its(:bookmarking_courses_ids) { should == [] }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'mongoid-doable'
+require 'database_cleaner'
+
+Mongoid.connect_to('doable_test')
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+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
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-doable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- aproxacs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Able to do something like 'bookmark', 'like' or 'follow' with mongoid
+email: aproxacs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- README.md
+- Rakefile
+- VERSION
+- lib/mongoid-doable.rb
+- lib/mongoid/doable.rb
+- spec/mongoid/doable_spec.rb
+- spec/spec_helper.rb
+- LICENSE.txt
+homepage: http://github.com/aproxacs/mongoid-doable
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 237706735236724821
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Able to do something like 'bookmark', 'like' or 'follow' with mongoid
+test_files: []