rs_voteable_mongo 1.0.0

data/lib/voteable_mongo/voteable.rb

@@ -0,0 +1,203 @@
+require 'voteable_mongo/voting'
+require 'voteable_mongo/integrations/mongoid'
+
+module Mongo
+  module Voteable
+    extend ActiveSupport::Concern
+
+    DEFAULT_VOTES = {
+      'up' => [],
+      'down' => [],
+      'up_count' => 0,
+      'down_count' => 0,
+      'count' => 0,
+      'point' => 0
+    }
+
+    included do
+      include Mongo::Voteable::Voting
+
+      if defined?(Mongoid) && defined?(field)
+        include Mongo::Voteable::Integrations::Mongoid
+      elsif defined?(MongoMapper)
+        include Mongo::Voteable::Integrations::MongoMapper
+      end
+      
+      scope :voted_by, lambda { |voter|
+        voter_id = Helpers.get_mongo_id(voter)
+        where('$or' => [{ 'votes.up' => voter_id }, { 'votes.down' => voter_id }])
+      }
+
+      scope :up_voted_by, lambda { |voter|
+        voter_id = Helpers.get_mongo_id(voter)
+        where('votes.up' => voter_id)
+      }
+
+      scope :down_voted_by, lambda { |voter|
+        voter_id = Helpers.get_mongo_id(voter)
+        where('votes.down' => voter_id)
+      }
+    end
+
+    # How many points should be assigned for each up or down vote and other options
+    # This hash should manipulated using voteable method
+    VOTEABLE = {}
+
+    module ClassMethods
+      # Set vote point for each up (down) vote on an object of this class
+      # 
+      # @param [Hash] options a hash containings:
+      # 
+      # voteable self, :up => +1, :down => -3
+      # voteable Post, :up => +2, :down => -1, :update_counters => false # skip counter update
+      def voteable(klass = self, options = nil)
+        VOTEABLE[name] ||= {}
+        VOTEABLE[name][klass.name] ||= options
+        if klass == self
+          if options[:index] == true
+            create_voteable_indexes
+          end
+        else
+          VOTEABLE[name][name][:update_parents] ||= true
+        end
+      end
+      
+      # Check if voter_id do a vote on votee_id
+      #
+      # @param [Hash] options a hash containings:
+      #   - :votee_id: the votee document id
+      #   - :voter_id: the voter document id
+      # 
+      # @return [true, false]
+      def voted?(options)
+        validate_and_normalize_vote_options(options)
+        up_voted?(options) || down_voted?(options)
+      end
+      
+      # Check if voter_id do an up vote on votee_id
+      #
+      # @param [Hash] options a hash containings:
+      #   - :votee_id: the votee document id
+      #   - :voter_id: the voter document id
+      # 
+      # @return [true, false]
+      def up_voted?(options)
+        validate_and_normalize_vote_options(options)
+        up_voted_by(options[:voter_id]).where(:_id => options[:votee_id]).count == 1
+      end
+      
+      # Check if voter_id do a down vote on votee_id
+      #
+      # @param [Hash] options a hash containings:
+      #   - :votee_id: the votee document id
+      #   - :voter_id: the voter document id
+      # 
+      # @return [true, false]
+      def down_voted?(options)
+        validate_and_normalize_vote_options(options)
+        down_voted_by(options[:voter_id]).where(:_id => options[:votee_id]).count == 1
+      end
+
+      def create_voteable_indexes
+        # Compound index _id and voters.up, _id and voters.down
+        # to make up_voted_by, down_voted_by, voted_by scopes and voting faster
+        # Should run in background since it introduce new index value and
+        # while waiting to build, the system can use _id for voting
+        # http://www.mongodb.org/display/DOCS/Indexing+as+a+Background+Operation
+        voteable_index({'votes.up' => 1, '_id' => 1}, {unique: true})
+        voteable_index({'votes.down' => 1, '_id' => 1}, {unique: true})
+
+        # Index counters and point for desc ordering
+        voteable_index({'votes.up_count' => -1})
+        voteable_index({'votes.down_count' => -1})
+        voteable_index({'votes.count' => -1})
+        voteable_index({'votes.point' => -1})
+        create_indexes
+      end
+    end
+    
+    # Make a vote on this votee
+    #
+    # @param [Hash] options a hash containings:
+    #   - :voter_id: the voter document id
+    #   - :value: vote :up or vote :down
+    #   - :revote: change from vote up to vote down
+    #   - :unvote: unvote the vote value (:up or :down)
+    def vote(options)
+      options[:votee_id] = id
+      options[:votee] = self
+      options[:voter_id] ||= options[:voter].id
+
+      if options[:unvote]
+        options[:value] ||= vote_value(options[:voter_id])
+      else
+        options[:revote] ||= vote_value(options[:voter_id]).present?
+      end
+
+      self.class.vote(options)
+    end
+  
+    # Get a voted value on this votee
+    #
+    # @param voter is object or the id of the voter who made the vote
+    def vote_value(voter)
+      voter_id = Helpers.get_mongo_id(voter)
+      return :up if up_voter_ids.include?(voter_id)
+      return :down if down_voter_ids.include?(voter_id)
+    end
+  
+    def voted_by?(voter)
+      !!vote_value(voter)
+    end
+
+    # Array of up voter ids
+    def up_voter_ids
+      votes.try(:[], 'up') || []
+    end
+
+    # Array of down voter ids
+    def down_voter_ids
+      votes.try(:[], 'down') || []
+    end
+
+    # Array of voter ids
+    def voter_ids
+      up_voter_ids + down_voter_ids
+    end
+
+    # Get the number of up votes
+    def up_votes_count
+      votes.try(:[], 'up_count') || 0
+    end
+
+    # Get the number of down votes
+    def down_votes_count
+      votes.try(:[], 'down_count') || 0
+    end
+
+    # Get the number of votes
+    def votes_count
+      votes.try(:[], 'count') || 0
+    end
+
+    # Get the votes point
+    def votes_point
+      votes.try(:[], 'point') || 0
+    end
+
+    # Get up voters
+    def up_voters(klass)
+      klass.where(:_id => { '$in' =>  up_voter_ids })
+    end
+
+    # Get down voters
+    def down_voters(klass)
+      klass.where(:_id => { '$in' => down_voter_ids })
+    end
+
+    # Get voters
+    def voters(klass)
+      klass.where(:_id => { '$in' => voter_ids })
+    end
+  end
+end

data/lib/voteable_mongo/voter.rb

@@ -0,0 +1,91 @@
+module Mongo
+  module Voter
+    extend ActiveSupport::Concern
+
+    included do
+      scope :up_voted_for, lambda { |votee| where(:_id => { '$in' =>  votee.up_voter_ids }) }
+      scope :down_voted_for, lambda { |votee| where(:_id => { '$in' =>  votee.down_voter_ids }) }
+      scope :voted_for, lambda { |votee| where(:_id => { '$in' =>  votee.voter_ids }) }
+    end
+
+    # Check to see if this voter voted on the votee or not
+    #
+    # @param [Hash, Object] options the hash containing the votee, or the votee itself
+    # @return [true, false] true if voted, false otherwise
+    def voted?(options)
+      unless options.is_a?(Hash)
+        votee_class = options.class
+        votee_id = options.id
+      else
+        votee = options[:votee]
+        if votee
+          votee_class = votee.class
+          votee_id = votee.id
+        else
+          votee_class = options[:votee_class]
+          votee_id = options[:votee_id]
+        end
+      end
+    
+      votee_class.voted?(:voter_id => id, :votee_id => votee_id)
+    end
+
+    # Get the voted value on a votee
+    #
+    # @param (see #voted?)
+    # @return [Symbol, nil] :up or :down or nil if not voted
+    def vote_value(options)
+      votee = unless options.is_a?(Hash)
+        options
+      else
+        options[:votee] || options[:votee_class].find(options[:votee_id])
+      end
+      votee.vote_value(_id)
+    end
+  
+    # Cancel the vote on a votee
+    #
+    # @param [Object] votee the votee to be unvoted
+    def unvote(options)
+      unless options.is_a?(Hash)
+        options = { :votee => options }
+      end
+      options[:unvote] = true
+      options[:revote] = false
+      vote(options)
+    end
+
+    # Vote on a votee
+    #
+    # @param (see #voted?)
+    # @param [:up, :down] vote_value vote up or vote down, nil to unvote
+    def vote(options, value = nil)
+      if options.is_a?(Hash)
+        votee = options[:votee]
+      else
+        votee = options
+        options = { :votee => votee, :value => value }
+      end
+
+      if votee
+        options[:votee_id] = votee.id
+        votee_class = votee.class
+      else
+        votee_class = options[:votee_class]
+      end
+    
+      if options[:value].nil?
+        options[:unvote] = true
+        options[:value] = vote_value(options)
+      else
+        options[:revote] = options.has_key?(:revote) ? !options[:revote].blank? : voted?(options)
+      end
+    
+      options[:voter] = self
+      options[:voter_id] = id
+
+      (votee || votee_class).vote(options)
+    end
+    
+  end
+end

data/lib/voteable_mongo/voting.rb

@@ -0,0 +1,214 @@
+module Mongo
+  module Voteable
+    module Voting
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        # Make a vote on an object of this class
+        #
+        # @param [Hash] options a hash containings:
+        #   - :votee_id: the votee document id
+        #   - :voter_id: the voter document id
+        #   - :value: :up or :down
+        #   - :revote: if true change vote vote from :up to :down and vise versa
+        #   - :unvote: if true undo the voting
+        # 
+        # @return [votee, false]
+        def vote(options)
+          validate_and_normalize_vote_options(options)
+          options[:voteable] = VOTEABLE[name][name]
+          
+          if options[:voteable]
+             query, update = if options[:revote]
+              revote_query_and_update(options)
+            elsif options[:unvote]
+              unvote_query_and_update(options)
+            else
+              new_vote_query_and_update(options)
+            end
+
+            # http://www.mongodb.org/display/DOCS/findAndModify+Command
+            begin
+              doc = where(query).find_and_modify(
+                update,
+                :new => true
+              )
+            rescue Moped::Errors::OperationFailure
+              doc = nil
+            end  
+
+            if doc
+              update_parent_votes(doc, options) if options[:voteable][:update_parents]
+              # Update new votes data
+              options[:votee].write_attribute('votes', doc['votes']) if options[:votee]
+              options[:votee] || new(doc.as_document)
+            else
+              false
+            end
+          end
+        end
+
+        
+        private
+          def validate_and_normalize_vote_options(options)
+            options.symbolize_keys!
+            options[:votee_id] = Helpers.try_to_convert_string_to_object_id(options[:votee_id])
+            options[:voter_id] = Helpers.try_to_convert_string_to_object_id(options[:voter_id])
+            options[:value] &&= options[:value].to_sym
+          end
+        
+          def new_vote_query_and_update(options)
+            if options[:value] == :up
+              positive_voter_ids = 'votes.up'
+              positive_votes_count = 'votes.up_count'
+            else
+              positive_voter_ids = 'votes.down'
+              positive_votes_count = 'votes.down_count'
+            end
+
+            return {
+              # Validate voter_id did not vote for votee_id yet
+              :_id => options[:votee_id],
+              'votes.up' => { '$ne' => options[:voter_id] },
+              'votes.down' => { '$ne' => options[:voter_id] }
+            }, {
+              # then update
+              '$push' => { positive_voter_ids => options[:voter_id] },
+              '$inc' => {
+                'votes.count' => +1,
+                positive_votes_count => +1,
+                'votes.point' => options[:voteable][options[:value]]
+              }
+            }
+          end
+
+          
+          def revote_query_and_update(options)
+            if options[:value] == :up
+              positive_voter_ids = 'votes.up'
+              negative_voter_ids = 'votes.down'
+              positive_votes_count = 'votes.up_count'
+              negative_votes_count = 'votes.down_count'
+              point_delta = options[:voteable][:up] - options[:voteable][:down]
+            else
+              positive_voter_ids = 'votes.down'
+              negative_voter_ids = 'votes.up'
+              positive_votes_count = 'votes.down_count'
+              negative_votes_count = 'votes.up_count'
+              point_delta = -options[:voteable][:up] + options[:voteable][:down]
+            end
+
+            return {
+              # Validate voter_id did a vote with value for votee_id
+              :_id => options[:votee_id],
+              # Can skip $ne validation since creating a new vote
+              # already warranty that a voter can vote one only
+              # positive_voter_ids => { '$ne' => options[:voter_id] },
+              negative_voter_ids => options[:voter_id]
+            }, {
+              # then update
+              '$pull' => { negative_voter_ids => options[:voter_id] },
+              '$push' => { positive_voter_ids => options[:voter_id] },
+              '$inc' => {
+                positive_votes_count => +1,
+                negative_votes_count => -1,
+                'votes.point' => point_delta
+              }
+            }
+          end
+          
+
+          def unvote_query_and_update(options)
+            if options[:value] == :up
+              positive_voter_ids = 'votes.up'
+              negative_voter_ids = 'votes.down'
+              positive_votes_count = 'votes.up_count'
+            else
+              positive_voter_ids = 'votes.down'
+              negative_voter_ids = 'votes.up'
+              positive_votes_count = 'votes.down_count'
+            end
+
+            return {
+              :_id => options[:votee_id],
+              # Validate if voter_id did a vote with value for votee_id
+              # Can skip $ne validation since creating a new vote 
+              # already warranty that a voter can vote one only
+              # negative_voter_ids => { '$ne' => options[:voter_id] },
+              positive_voter_ids => options[:voter_id]
+            }, {
+              # then update
+              '$pull' => { positive_voter_ids => options[:voter_id] },
+              '$inc' => {
+                positive_votes_count => -1,
+                'votes.count' => -1,
+                'votes.point' => - options[:voteable][options[:value]]
+              }
+            }
+          end
+          
+
+          def update_parent_votes(doc, options)
+            VOTEABLE[name].each do |class_name, voteable|
+                
+              if metadata = voteable_relation(class_name)
+                
+                if (parent_id = doc[voteable_foreign_key(metadata)]).present?
+                  parent_ids = parent_id.is_a?(Array) ? parent_id : [ parent_id ]
+                  class_name.constantize.collection.find({'_id' => {'$in' => parent_ids}}).update_all(
+                    { '$inc' => parent_inc_options(voteable, options) },
+                  )
+                end
+              end
+            end
+          end
+
+          
+          def parent_inc_options(voteable, options)
+            inc_options = {}
+
+            if options[:revote]
+              if options[:value] == :up
+                inc_options['votes.point'] = voteable[:up] - voteable[:down]
+                unless voteable[:update_counters] == false
+                  inc_options['votes.up_count'] = +1
+                  inc_options['votes.down_count'] = -1
+                end
+              else
+                inc_options['votes.point'] = -voteable[:up] + voteable[:down]
+                unless voteable[:update_counters] == false
+                  inc_options['votes.up_count'] = -1
+                  inc_options['votes.down_count'] = +1
+                end
+              end
+
+            elsif options[:unvote]
+              inc_options['votes.point'] = -voteable[options[:value]]
+              unless voteable[:update_counters] == false
+                inc_options['votes.count'] = -1
+                if options[:value] == :up
+                  inc_options['votes.up_count'] = -1
+                else
+                  inc_options['votes.down_count'] = -1
+                end
+              end
+
+            else # new vote
+              inc_options['votes.point'] = voteable[options[:value]]
+              unless voteable[:update_counters] == false
+                inc_options['votes.count'] = +1
+                if options[:value] == :up
+                  inc_options['votes.up_count'] = +1
+                else
+                  inc_options['votes.down_count'] = +1
+                end
+              end
+            end
+
+            inc_options
+          end
+      end
+            
+    end
+  end
+end

data/lib/voteable_mongo.rb

@@ -0,0 +1,8 @@
+require 'voteable_mongo/helpers'
+require 'voteable_mongo/voteable'
+require 'voteable_mongo/voter'
+require 'voteable_mongo/tasks'
+
+if defined?(Rails)
+  require 'voteable_mongo/railtie'
+end

data/spec/.rspec

@@ -0,0 +1 @@
+--color --debugger

data/spec/mongoid/models/category.rb

@@ -0,0 +1,10 @@
+class Category
+  include Mongoid::Document
+  include Mongo::Voteable
+
+  field :name  
+
+  has_and_belongs_to_many :posts
+  
+  voteable self, :index => true
+end

data/spec/mongoid/models/comment.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'post')
+
+class Comment
+  include Mongoid::Document
+  include Mongo::Voteable
+
+  field :content
+
+  belongs_to :post
+  
+  voteable self, :up => +1, :down => -3
+  voteable Post, :up => +2, :down => -1
+end

data/spec/mongoid/models/post.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'category')
+
+class Post
+  include Mongoid::Document
+  include Mongo::Voteable
+
+  field :title
+  field :content
+  
+  has_and_belongs_to_many :categories
+  has_many :comments
+  
+  field :_id, type: String, default: -> { title }
+  
+  voteable self, :up => +1, :down => -1, :index => true
+  voteable Category, :up => +3, :down => -5, :update_counters => false
+end

data/spec/mongoid/models/user.rb

@@ -0,0 +1,4 @@
+class User
+  include Mongoid::Document
+  include Mongo::Voter
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'mongoid'
+models_folder = File.join(File.dirname(__FILE__), 'mongoid/models')
+Mongoid.configure do |config|
+  name = 'voteable_mongo_test'
+  host = 'localhost'
+  config.connect_to(name)
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+
+require 'voteable_mongo'
+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
+  begin
+    klass.collection.drop
+  rescue Exception => e
+    print e.message
+  end
+}

data/spec/voteable_mongo/tasks_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Mongo::Voteable::Tasks do
+  describe 'Mongo::Voteable::Tasks.init_stats' do
+    before :all do
+      @post1 = Post.create!(:title => 'post1')
+      @post2 = Post.create!(:title => 'post2')
+    end
+
+    it 'after create votes has default value' do
+      @post1.votes.should == ::Mongo::Voteable::DEFAULT_VOTES
+      @post2.votes.should == ::Mongo::Voteable::DEFAULT_VOTES
+    end
+    
+    it 'reset votes data' do
+      @post1.votes = nil
+      @post1.save
+
+      @post2.votes = nil
+      @post2.save
+    end
+    
+    it 'init_stats recover votes default value' do
+      ::Mongo::Voteable::Tasks.init_stats
+      ::Mongo::Voteable::Tasks.migrate_old_votes
+
+      @post1.reload
+      @post2.reload
+
+      @post1.votes.should == ::Mongo::Voteable::DEFAULT_VOTES
+      @post2.votes.should == ::Mongo::Voteable::DEFAULT_VOTES
+    end
+  end
+end