mongo_followable 0.2.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mongo_followable.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jie Fan
+
+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.rdoc

@@ -0,0 +1,115 @@
+= mongo_followable
+
+Now works for both Mongoid and Mongo_Mapper!
+
+== Installation
+
+In console:
+  gem install mongo_followable
+or in Gemfile:
+  gem 'mongo_followable', "~> 0.2.0"
+
+== Usage
+
+To make model followable you need to include Mongo::Followable into your document;Meanwhile, you also need to include Mongo::Follower in your follower model:
+  class User
+    include Mongo::Document
+    include Mongo::Followable
+    include Mongo::Follower
+  end
+
+  class Group
+    include Mongo::Document
+    include Mongo::Followable
+  end
+
+Now you can set authorization:
+    current_user.set_authorization('user', 'game') # now current_user cannot follow User and Game model
+    current_user.unset_authorization('User', 'Game')
+
+And then you can follow a model:
+
+    @group = Group.new
+    @group.save
+
+    current_user.follow(@group)
+    current_user.unfollow(@group)
+
+You can also judge whether a model is a follower of another model or a model is a followee of another model:
+    	
+    current_user.follower_of?(@group)
+    current_user.followee_of?(@group)
+
+Moreover, it's easy to get a model's follower/followee count:
+
+    current_user.followers_count
+    current_user.followees_count
+
+Of course, you can get a list of followers/followees:
+    	
+    User.followers_of(@group)
+    User.followees_of(@group)
+
+    @group.all_followers
+    @user.all_followees
+
+Getting a model's followers/followees by type is also possible:
+
+    @group.followers_by_type("user")
+    @user.followees_by_type("group")
+
+And their count:
+
+    @group.followers_by_type("user")
+    @group.followers_count_by_type("user")
+    @user.followees_by_type("group")
+    @user.followees_count_by_type("group")
+
+You can also get a model's follow/followed history:
+
+    @user.ever_follow
+    @group.ever_followed
+
+Another feature is to get a list of models which has the most followers/followees:
+
+    User.with_max_followees
+    User.with_min_followees
+    User.with_max_followees_by_type('group')
+    User.with_min_followees_by_type('group')
+    Group.with_max_followers
+    Group.with_min_followers
+    Group.with_max_followers_by_type('user')
+    Group.with_min_followers_by_type('user')
+
+Now you can tell if two models have some common followers/followees by following methods:
+
+    @user.common_followees?(@another_user)
+    @user.common_followers?(@group)
+
+And see what the common followers/followees are:
+
+    @user.common_followees_with(@another_user)
+    @user.common_followers_with(@group)
+    
+* Any bug or issue, please send me an email: ustc.flyingfox@gmail.com
+
+== TODO
+
+* inter-models followable #FINISHED#
+* divide into two parts: followable(being followed) and follower(following others) #FINISHED#
+* following history/followed history #FINISHED#
+* most/least followed/following #FINISHED
+* add authorization to followable models #FINISHED#
+* common followers/followees #FINISHED#
+* add support for mongo_mapper in next version #FINISHED#
+
+!!If you have any advice, plese do not hesitate to tell me!!
+
+== Thanks
+
+Thanks the author(s) of acts_as_followable, you can find this gem here[https://github.com/xpepermint/acts_as_followable]
+Thanks the author(s) of voteable_mongo, you can find this gem here[https://github.com/vinova/voteable_mongo]
+
+== Copyright
+
+Copyright (c) Jie Fan. See LICENSE.txt for further details.    

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/app/models/follow.rb

@@ -0,0 +1,19 @@
+class Follow
+  if defined?(Mongoid)
+    include Mongoid::Document
+
+    field :f_type, :type => String
+    field :f_id, :type => String
+  elsif defined?(MongoMapper)
+    include MongoMapper::Document
+
+    key :f_type, :type => String
+    key :f_id, :type => String
+  end
+
+  belongs_to :followable, :polymorphic => true
+  belongs_to :following, :polymorphic => true
+
+  scope :by_type, lambda { |type| where(:f_type => type.capitalize) }
+  scope :by_model, lambda { |model| where(:f_id => model.id.to_s).by_type(model.class.name) }
+end

data/lib/mongo_followable/followable.rb

@@ -0,0 +1,185 @@
+module Mongo
+  module Followable
+    extend ActiveSupport::Concern
+
+    included do |base|
+      if defined?(Mongoid)
+        base.field :cannot_followed, :type => Array, :default => []
+        base.field :followed_history, :type => Array, :default => []
+        base.has_many :followers, :class_name => "Follow", :as => :followable, :dependent => :destroy
+      elsif defined?(MongoMapper)
+        base.key :cannot_followed, :type => Array, :default => []
+        base.key :followed_history, :type => Array, :default => []
+        base.many :followers, :class_name => "Follow", :as => :followable, :dependent => :destroy
+      end
+    end
+
+    module ClassMethods
+
+      # get certain model's followees of this type
+      #
+      # Example:
+      #   >> @jim = User.new
+      #   >> @ruby = Group.new
+      #   >> @jim.save
+      #   >> @ruby.save
+      #
+      #   >> @jim.follow(@ruby)
+      #   >> User.followees_of(@jim)
+      #   => [@ruby]
+      #
+      #   Arguments:
+      #     model: instance of some followable model
+
+      def followees_of(model)
+        model.followees_by_type(self.name)
+      end
+
+      # 4 methods in this function
+      #
+      # Example:
+      #   >> Group.with_max_followers
+      #   => [@ruby]
+      #   >> Group.with_max_followers_by_type('user')
+      #   => [@ruby]
+
+      def method_missing(name, *args)
+        if name.to_s =~ /^with_(max|min)_followers$/i
+          follow_array = self.all.to_a.sort! { |a, b| a.followers_count <=> b.followers_count }
+          if $1 == "max"
+            max = follow_array[-1].followers_count
+            follow_array.select { |c| c.followers_count == max }
+          elsif $1 == "min"
+            min = follow_array[0].followers_count
+            follow_array.select { |c| c.followers_count == min }
+          end
+        elsif name.to_s =~ /^with_(max|min)_followers_by_type$/i
+          follow_array = self.all.to_a.sort! { |a, b| a.followers_count_by_type(args[0]) <=> b.followers_count_by_type(args[0]) }
+          if $1 == "max"
+            max = follow_array[-1].followers_count_by_type(args[0])
+            follow_array.select { |c| c.followers_count_by_type(args[0]) == max }
+          elsif $1 == "min"
+            min = follow_array[0].followers_count
+            follow_array.select { |c| c.followers_count_by_type(args[0]) == min }
+          end
+        else
+          super
+        end
+      end
+
+    end
+
+    # set which mongoid cannot follow self
+    #
+    # Example:
+    #   >> @ruby.set_authorization('user')
+    #   => true
+
+    def set_authorization(*models)
+      models.each do |model|
+        self.cannot_followed << model.capitalize
+      end
+      self.save
+    end
+
+    def unset_authorization(*models)
+      models.each do |model|
+        self.cannot_followed -= [model.capitalize]
+      end
+      self.save
+    end
+
+    # see if this model is followee of some model
+    #
+    # Example:
+    #   >> @ruby.followee_of?(@jim)
+    #   => true
+
+    def followee_of?(model)
+      0 < self.followers.by_model(model).limit(1).count * model.followees.by_model(self).limit(1).count
+    end
+
+    # get all the followers of this model, same with classmethod followers_of
+    #
+    # Example:
+    #   >> @ruby.all_followers
+    #   => [@jim]
+
+    def all_followers
+      rebuild_instances(self.followers)
+    end
+
+    # get all the followers of this model in certain type
+    #
+    # Example:
+    #   >> @ruby.followers_by_type("user")
+    #   => [@jim]
+
+    def followers_by_type(type)
+      rebuild_instances(self.followers.by_type(type))
+    end
+
+    # get the number of followers
+    #
+    # Example:
+    #   >> @ruby.followers_count
+    #   => 1
+
+    def followers_count
+      self.followers.count
+    end
+
+    # get the number of followers in certain type
+    #
+    # Example:
+    #   >> @ruby.followers_count_by_type("user")
+    #   => 1
+
+    def followers_count_by_type(type)
+      self.followers.by_type(type).count
+    end
+
+    # see model's followed history
+    #
+    # Example:
+    #   >> @ruby.ever_followed
+    #   => [@jim]
+
+    def ever_followed
+      follow = []
+      self.followed_history.each do |h|
+        follow << h.split('_')[0].constantize.find(h.split('_')[1])
+      end
+      follow
+    end
+
+    # return if there is any common followers
+    #
+    # Example:
+    #   >> @ruby.common_followees?(@python)
+    #   => true
+
+    def common_followers?(model)
+      0 < (rebuild_instances(self.followers) & rebuild_instances(model.followers)).length
+    end
+
+    # get common followers with some model
+    #
+    # Example:
+    #   >> @ruby.common_followers_with(@python)
+    #   => [@jim]
+
+    def common_followers_with(model)
+      rebuild_instances(self.followers) & rebuild_instances(model.followers)
+    end
+
+    private
+      def rebuild_instances(follows)
+        follow_list = []
+        follows.each do |follow|
+          follow_list << follow.f_type.capitalize.constantize.find(follow.f_id)
+        end
+        follow_list
+      end
+  end
+end

data/lib/mongo_followable/follower.rb

@@ -0,0 +1,213 @@
+module Mongo
+  module Follower
+    extend ActiveSupport::Concern
+
+    included do |base|
+      if defined?(Mongoid)
+        base.field :cannot_follow, :type => Array, :default => []
+        base.field :follow_history, :type => Array, :default => []
+        base.has_many :followees, :class_name => "Follow", :as => :following, :dependent => :destroy
+      elsif defined?(MongoMapper)
+        base.key :cannot_follow, :type => Array, :default => []
+        base.key :follow_history, :type => Array, :default => []
+        base.many :followees, :class_name => "Follow", :as => :following, :dependent => :destroy
+      end
+    end
+
+    module ClassMethods
+
+      # get certain model's followers of this type
+      #
+      # Example:
+      #   >> @jim = User.new
+      #   >> @ruby = Group.new
+      #   >> @jim.save
+      #   >> @ruby.save
+      #
+      #   >> @jim.follow(@ruby)
+      #   >> User.followers_of(@ruby)
+      #   => [@jim]
+      #
+      #   Arguments:
+      #     model: instance of some followable model
+
+      def followers_of(model)
+        model.followers_by_type(self.name)
+      end
+
+      # 4 methods in this function
+      #
+      # Example:
+      #   >> User.with_max_followees
+      #   => [@jim]
+      #   >> User.with_max_followees_by_type('group')
+      #   => [@jim]
+
+      def method_missing(name, *args)
+        if name.to_s =~ /^with_(max|min)_followees$/i
+          follow_array = self.all.to_a.sort! { |a, b| a.followees_count <=> b.followees_count }
+          if $1 == "max"
+            max = follow_array[-1].followees_count
+            follow_array.select { |c| c.followees_count == max }
+          elsif $1 == "min"
+            min = follow_array[0].followees_count
+            follow_array.select { |c| c.followees_count == min }
+          end
+        elsif name.to_s =~ /^with_(max|min)_followees_by_type$/i
+          follow_array = self.all.to_a.sort! { |a, b| a.followees_count_by_type(args[0]) <=> b.followees_count_by_type(args[0]) }
+          if $1 == "max"
+            max = follow_array[-1].followees_count_by_type(args[0])
+            follow_array.select { |c| c.followees_count_by_type(args[0]) == max }
+          elsif $1 == "min"
+            min = follow_array[0].followees_count
+            follow_array.select { |c| c.followees_count_by_type(args[0]) == min }
+          end
+        else
+          super
+        end
+      end
+
+    end
+
+    # set which mongoid user cannot follow
+    #
+    # Example:
+    #   >> @jim.set_authorization('group', 'user')
+    #   => true
+
+    def set_authorization(*models)
+      models.each do |model|
+        self.cannot_follow << model.capitalize
+      end
+      self.save
+    end
+
+    #unset which mongoid user cannot follow
+
+    def unset_authorization(*models)
+      models.each do |model|
+        self.cannot_follow -= [model.capitalize]
+      end
+      self.save
+    end
+
+    # see if this model is follower of some model
+    #
+    # Example:
+    #   >> @jim.follower_of?(@ruby)
+    #   => true
+
+    def follower_of?(model)
+      0 < self.followees.by_model(model).limit(1).count * model.followers.by_model(self).limit(1).count
+    end
+
+    # get all the followees of this model, same with classmethod followees_of
+    #
+    # Example:
+    #   >> @jim.all_followees
+    #   => [@ruby]
+
+    def all_followees
+      rebuild_instances(self.followees)
+    end
+
+    # get all the followees of this model in certain type
+    #
+    # Example:
+    #   >> @ruby.followees_by_type("group")
+    #   => [@ruby]
+
+    def followees_by_type(type)
+      rebuild_instances(self.followees.by_type(type))
+    end
+
+    # follow some model
+
+    def follow(*models)
+      models.each do |model|
+        unless model == self or self.follower_of?(model) or model.followee_of?(self) or self.cannot_follow.include?(model.class.name) or model.cannot_followed.include?(self.class.name)
+          model.followers.create!(:f_type => self.class.name, :f_id => self.id.to_s)
+          model.followed_history << self.class.name + '_' + self.id.to_s
+          model.save
+          self.followees.create!(:f_type => model.class.name, :f_id => model.id.to_s)
+          self.follow_history << model.class.name + '_' + model.id.to_s
+          self.save
+        end
+      end
+    end
+
+    # unfollow some model
+
+    def unfollow(*models)
+      models.each do |model|
+        unless model == self or !self.follower_of?(model) or !model.followee_of?(self) or self.cannot_follow.include?(model.class.name) or model.cannot_followed.include?(self.class.name)
+          model.followers.by_model(self).first.destroy
+          self.followees.by_model(model).first.destroy
+        end
+      end
+    end
+
+    # get the number of followees
+    #
+    # Example:
+    #   >> @jim.followers_count
+    #   => 1
+
+    def followees_count
+      self.followees.count
+    end
+
+    # get the number of followers in certain type
+    #
+    # Example:
+    #   >> @ruby.followers_count_by_type("user")
+    #   => 1
+
+    def followees_count_by_type(type)
+      self.followees.by_type(type).count
+    end
+
+    # see user's follow history
+    #
+    # Example:
+    #   >> @jim.ever_follow
+    #   => [@ruby]
+
+    def ever_follow
+      follow = []
+      self.follow_history.each do |h|
+        follow << h.split('_')[0].constantize.find(h.split('_')[1])
+      end
+      follow
+    end
+
+    # return if there is any common followees
+    #
+    # Example:
+    #   >> @jim.common_followees?(@tom)
+    #   => true
+
+    def common_followees?(model)
+      0 < (rebuild_instances(self.followees) & rebuild_instances(model.followees)).length
+    end
+
+    # get common followees with some model
+    #
+    # Example:
+    #   >> @jim.common_followees_with(@tom)
+    #   => [@ruby]
+
+    def common_followees_with(model)
+      rebuild_instances(self.followees) & rebuild_instances(model.followees)
+    end
+
+    private
+      def rebuild_instances(follows)
+        follow_list = []
+        follows.each do |follow|
+          follow_list << follow.f_type.capitalize.constantize.find(follow.f_id)
+        end
+        follow_list
+      end
+  end
+end

data/lib/mongo_followable/version.rb

@@ -0,0 +1,3 @@
+module MongoFollowable
+  VERSION = "0.2.0"
+end

data/lib/mongo_followable.rb

@@ -0,0 +1,7 @@
+#require "mongo_followable/followable"
+#require "mongo_followable/follower"
+#require "../app/models/follow"
+
+require File.join(File.dirname(__FILE__), "mongo_followable/followable")
+require File.join(File.dirname(__FILE__), "mongo_followable/follower")
+require File.join(File.dirname(__FILE__), "../app/models/follow")

data/mongo_followable.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mongo_followable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mongo_followable"
+  s.version     = MongoFollowable::VERSION
+  s.authors     = ["Jie Fan"]
+  s.email       = ["ustc.flyingfox@gmail.com"]
+  s.homepage    = "https://github.com/lastomato/mongo_followable"
+  s.summary     = %q{ adds following feature to mongoid }
+  s.description = %q{ Mongo Followable adds following feature to mongoid }
+
+  s.rubyforge_project = "mongo_followable"
+
+  s.add_development_dependency('rspec', '~> 2.6')
+  s.add_development_dependency('mongoid', '~> 2.0')
+  s.add_development_dependency('mongo_mapper', '~> 0.9')
+  s.add_development_dependency('bson_ext', '~> 1.4')
+  s.add_development_dependency('database_cleaner', '~>0.6')
+
+  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/mongo/followable_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Mongo::Followable do
+
+  describe User do
+
+    let!(:u) { User.new }
+
+    context "begins" do
+
+      before do
+      	u.save
+
+        @v = User.new
+        @v.save
+
+        @g = Group.new
+        @g.save
+      end
+
+      it "following a user" do
+        u.follow(@v)
+
+        u.follower_of?(@v).should be_true
+        @v.followee_of?(u).should be_true
+
+        u.all_followees.should == [@v]
+        @v.all_followers.should == [u]
+
+        u.followees_by_type("user").should == [@v]
+        @v.followers_by_type("user").should == [u]
+
+        u.followees_count.should == 1
+        @v.followers_count.should == 1
+
+        u.followees_count_by_type("user").should == 1
+        @v.followers_count_by_type("user").should == 1
+
+        u.ever_follow.should == [@v]
+        @v.ever_followed.should == [u]
+
+        u.common_followees?(@v).should be_false
+        @v.common_followers?(u).should be_false
+        u.common_followees_with(@v).should == []
+        @v.common_followers_with(u).should == []
+
+        User.with_max_followees.should == [u]
+        User.with_max_followers.should == [@v]
+        User.with_max_followees_by_type('user').should == [u]
+        User.with_max_followers_by_type('user').should == [@v]
+      end
+
+      it "unfollowing a user" do
+        u.unfollow(@v)
+
+        u.follower_of?(@v).should be_false
+        @v.followee_of?(u).should be_false
+
+        u.all_followees.should == []
+        @v.all_followers.should == []
+
+        u.followees_by_type("user").should == []
+        @v.followers_by_type("user").should == []
+
+        u.followees_count.should == 0
+        @v.followers_count.should == 0
+
+        u.followees_count_by_type("user").should == 0
+        @v.followers_count_by_type("user").should == 0
+      end
+
+      it "following a group" do
+        u.follow(@g)
+
+        u.follower_of?(@g).should be_true
+        @g.followee_of?(u).should be_true
+
+        u.all_followees.should == [@g]
+        @g.all_followers.should == [u]
+
+        u.followees_by_type("group").should == [@g]
+        @g.followers_by_type("user").should == [u]
+
+        u.followees_count.should == 1
+        @g.followers_count.should == 1
+
+        u.followees_count_by_type("group").should == 1
+        @g.followers_count_by_type("user").should == 1
+
+        u.follow(@v)
+
+        u.ever_follow.should == [@g, @v]
+        @g.ever_followed.should == [u]
+
+        u.common_followees?(@v).should be_false
+        @v.common_followers?(@g).should be_true
+        u.common_followees_with(@v).should == []
+        @v.common_followers_with(@g).should == [u]
+
+        User.with_max_followees.should == [u]
+        Group.with_max_followers.should == [@g]
+        User.with_max_followees_by_type('group').should == [u]
+        Group.with_max_followers_by_type('user').should == [@g]
+      end
+
+      it "unfollowing a group" do
+        u.unfollow(@g)
+
+        u.follower_of?(@g).should be_false
+        @g.followee_of?(u).should be_false
+
+        u.all_followees.should == []
+        @g.all_followers.should == []
+
+        u.followees_by_type("group").should == []
+        @g.followers_by_type("group").should == []
+
+        u.followees_count.should == 0
+        @g.followers_count.should == 0
+
+        u.followees_count_by_type("group").should == 0
+        @g.followers_count_by_type("group").should == 0
+      end
+    end
+  end
+end

data/spec/mongo_mapper/group.rb

@@ -0,0 +1,4 @@
+class Group
+  include MongoMapper::Document
+  include Mongo::Followable
+end

data/spec/mongo_mapper/user.rb

@@ -0,0 +1,5 @@
+class User
+  include MongoMapper::Document
+  include Mongo::Followable
+  include Mongo::Follower
+end

data/spec/mongoid/group.rb

@@ -0,0 +1,4 @@
+class Group
+  include Mongoid::Document
+  include Mongo::Followable
+end

data/spec/mongoid/user.rb

@@ -0,0 +1,5 @@
+class User
+  include Mongoid::Document
+  include Mongo::Followable
+  include Mongo::Follower
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require "rubygems"
+require "bundler/setup"
+
+require "database_cleaner"
+require "rspec"
+
+if rand > 0.5
+  puts 'Mongoid'
+  require 'mongoid'
+  require File.expand_path("../../lib/mongo_followable", __FILE__)
+  require File.expand_path("../mongoid/user", __FILE__)
+  require File.expand_path("../mongoid/group", __FILE__)
+  Mongoid.configure do |config|
+    name = 'voteable_mongo_test'
+    host = 'localhost'
+    config.master = Mongo::Connection.new.db(name)
+    config.autocreate_indexes = true
+  end
+else
+  puts 'MongoMapper'
+  require 'mongo_mapper'
+  require File.expand_path("../../lib/mongo_followable", __FILE__)
+  require File.expand_path("../mongo_mapper/user", __FILE__)
+  require File.expand_path("../mongo_mapper/group", __FILE__)
+  MongoMapper.database = 'voteable_mongo_test'
+end
+
+RSpec.configure do |c|
+  c.before(:all)  { DatabaseCleaner.strategy = :truncation }
+  c.before(:each) { DatabaseCleaner.clean }
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification 
+name: mongo_followable
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Jie Fan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-06 01:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mongo_mapper
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        version: "0.6"
+  type: :development
+  version_requirements: *id005
+description: " Mongo Followable adds following feature to mongoid "
+email: 
+- ustc.flyingfox@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- app/models/follow.rb
+- lib/mongo_followable.rb
+- lib/mongo_followable/followable.rb
+- lib/mongo_followable/follower.rb
+- lib/mongo_followable/version.rb
+- mongo_followable.gemspec
+- spec/mongo/followable_spec.rb
+- spec/mongo_mapper/group.rb
+- spec/mongo_mapper/user.rb
+- spec/mongoid/group.rb
+- spec/mongoid/user.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/lastomato/mongo_followable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: mongo_followable
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: adds following feature to mongoid
+test_files: []
+