voteable_mongoid 0.4.1 → 0.4.2

data/README.rdoc

@@ -1,8 +1,10 @@
-= Votable Mongoid
+= Voteable Mongoid
 
-Votable Mongoid allows you to make your Mongoid::Document objects votable (up or down)
+Voteable Mongoid allows you to make your Mongoid::Document objects voteable (up or down)
 
-For instance, in a q&a site, a user can vote up (or down) on a post or a comment.
+For instance, in a Q&A site, a user can vote up (or down) on a post or a comment.
+
+When user provided enough information, voteable_mongoid will use only one update-in-place operation per collection.
 
 == Installation
 
@@ -10,13 +12,13 @@ For instance, in a q&a site, a user can vote up (or down) on a post or a comment
 
 To install the gem, add this to your Gemfile
 
-  gem 'votable_mongoid'
+  gem 'voteable_mongoid'
 
 After that, remember to run "bundle install"
 
 == Usage
 
-=== Making Post and Comment votable, User being the voter
+=== Making Post and Comment voteable, User being the voter
 
 post.rb
 
@@ -77,9 +79,11 @@ user.rb
 
     @user.unvote(@comment)
 
-== Contributors
+== Credits
 
-* Alex N. - Author, Maintainer
+* Alex N. - Author
 * Stefan N. - Unvoting
 
-Copyright (c) 2010-2011 Alex Nguyen (http://alex.vinova.sg) and Vinova Pre Ltd (http://vinova.sg)
+Copyright (c) 2010-2011 Vinova Pte Ltd (http://vinova.sg)
+
+Licensed under the MIT license.

data/lib/mongoid/voteable.rb

@@ -3,7 +3,7 @@ module Mongoid
     extend ActiveSupport::Concern
 
     # How many points should be assigned for each up or down vote.
-    # This array should be manipulated using Votable.vote_point method
+    # This array should be manipulated using Voteable.vote_point method
     VOTE_POINT = {}
 
     included do
@@ -38,127 +38,140 @@ module Mongoid
       #   - :voter_id: the voter document id
       #   - :value: :up or :down
       #   - :revote: change from vote up to vote down
+      #   - :unvote: unvote the vote value (:up or :down)
       def self.vote(options)
         options.symbolize_keys!
+        value = options[:value].to_sym
         
         votee_id = options[:votee_id]
         voter_id = options[:voter_id]
-        value = options[:value]
         
         votee_id = BSON::ObjectId(votee_id) if votee_id.is_a?(String)
         voter_id = BSON::ObjectId(voter_id) if voter_id.is_a?(String)
 
-        value = value.to_sym
-        value_point = VOTE_POINT[self.name][self.name]
+        klass = options[:class]
+        klass ||= VOTE_POINT.keys.include?(name) ? name : collection.name.classify
+        value_point = VOTE_POINT[klass][klass]
         
         if options[:revote]
           if value == :up
-            push_field = :up_voter_ids
-            pull_field = :down_voter_ids
+            positive_field = :up_voter_ids
+            negative_field = :down_voter_ids
             point_delta = value_point[:up] - value_point[:down]
           else
-            push_field = :down_voter_ids
-            pull_field = :up_voter_ids
+            positive_field = :down_voter_ids
+            negative_field = :up_voter_ids
             point_delta = -value_point[:up] + value_point[:down]
           end
           
-          collection.update({ 
+          update_result = collection.update({ 
+            # Validate voter_id did a vote with value for votee_id
             :_id => votee_id,
-            push_field => { '$ne' => voter_id },
-            pull_field => voter_id
+            positive_field => { '$ne' => voter_id },
+            negative_field => voter_id
           }, {
-            '$pull' => { pull_field => voter_id },
-            '$push' => { push_field => voter_id },
+            # then update
+            '$pull' => { negative_field => voter_id },
+            '$push' => { positive_field => voter_id },
             '$inc' => {
               :votes_point => point_delta
             }
+          }, {
+            :safe => true
           })
 
+        elsif options[:unvote]
+          if value == :down
+            positive_field = :down_voter_ids
+            negative_field = :up_voter_ids
+          else
+            positive_field = :up_voter_ids
+            negative_field = :down_voter_ids
+          end
+          
+          # Check if voter_id did a vote with value for votee_id
+          update_result = collection.update({ 
+            # Validate voter_id did a vote with value for votee_id
+            :_id => votee_id,
+            negative_field => { '$ne' => voter_id },
+            positive_field => voter_id
+          }, {
+            # then update
+            '$pull' => { positive_field => voter_id },
+            '$inc' => {
+              :votes_count => -1,
+              :votes_point => -value_point[value]
+            }
+          }, {
+            :safe => true
+          })
+          
         else # new vote
           if value.to_sym == :up
-            push_field = :up_voter_ids
+            positive_field = :up_voter_ids
           else
-            push_field = :down_voter_ids
+            positive_field = :down_voter_ids
           end
 
-          collection.update({ 
+          update_result = collection.update({ 
+            # Validate voter_id did not vote for votee_id yet
             :_id => votee_id,
             :up_voter_ids => { '$ne' => voter_id },
             :down_voter_ids => { '$ne' => voter_id },
           }, {
-            '$push' => { push_field => voter_id },
+            # then update
+            '$push' => { positive_field => voter_id },
             '$inc' => {
               :votes_count => +1,
               :votes_point => value_point[value]
             }
+          }, {
+            :safe => true
           })
         end
         
-        VOTE_POINT[self.name].each do |class_name, value_point|
-          next unless relation_metadata = relations[class_name.underscore]
-          next unless foreign_key_value = options[relation_metadata.foreign_key.to_sym]
-          foreign_key_value = BSON::ObjectId(foreign_key_value) if foreign_key_value.is_a?(String)
-          
-          class_name.constantize.collection.update({ :_id => foreign_key_value }, {
-            '$inc' => options[:revote] ? {
-              :votes_point => ( value == :up ? 
-                 value_point[:up] - value_point[:down] : 
-                -value_point[:up] + value_point[:down] )
-            } : {
-              :votes_count => value_point[:not_increase_votes_count] ? 0 : 1,
-              :votes_point => value_point[value]
-            }
-          })
-        end
-      end
+        # Only update parent class if votee is updated successfully
+        successed = ( update_result['err'] == nil and 
+          update_result['updatedExisting'] == true and
+          update_result['n'] == 1 )
 
-      # Cancel 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: voted :up or :down
-      def self.unvote(options)
-        options.symbolize_keys!
-                
-        voter_id = options[:voter_id]
-        voter_id = BSON::ObjectId(voter_id) if voter_id.is_a?(String)
-        votee_id = options[:votee_id]
-        votee_id = BSON::ObjectId(votee_id) if votee_id.is_a?(String)
-        value = options[:value].to_sym
-        return unless value  # not voted yet!
-        
-        value_point = VOTE_POINT[self.name][self.name]
-        
-        pull_field = if value == :up
-            :up_voter_ids
-        else
-            :down_voter_ids
-        end
-        
-        collection.update({ 
-          :_id => votee_id,
-        }, {
-          '$pull' => { pull_field => voter_id },
-          '$inc' => {
-            :votes_count => -1,
-            :votes_point => -value_point[value]
-          }
-        })
-        
-        VOTE_POINT[self.name].each do |class_name, value_point|
-          next unless relation_metadata = relations[class_name.underscore]
-          next unless foreign_key_value = options[relation_metadata.foreign_key.to_sym]
-          foreign_key_value = BSON::ObjectId(foreign_key_value) if foreign_key_value.is_a?(String)
+        if successed
+          VOTE_POINT[klass].each do |class_name, value_point|
+            # For other class in VOTE_POINT options, if is parent of current class
+            next unless relation_metadata = relations[class_name.underscore]
+            votee ||= options[:votee] || find(options[:votee_id])
+            # If can find current votee foreign_key value for that class
+            next unless foreign_key_value = votee.read_attribute(relation_metadata.foreign_key.to_sym)
           
-          class_name.constantize.collection.update({ :_id => foreign_key_value }, {
-            '$inc' => {
-              :votes_count => value_point[:not_increase_votes_count] ? 0 : -1,
-              :votes_point => -value_point[value]
-            }
-          })
+            # Update that class / collection
+            inc_options = if options[:revote]
+              {
+                :votes_point => ( value == :up ? 
+                   value_point[:up] - value_point[:down] : 
+                  -value_point[:up] + value_point[:down] )
+              }
+            elsif options[:unvote]
+              {
+                :votes_count => value_point[:not_increase_votes_count] ? 0 : -1,
+                :votes_point => -value_point[value]
+              }
+            else
+              {
+                :votes_count => value_point[:not_increase_votes_count] ? 0 : 1,
+                :votes_point => value_point[value]
+              }
+            end
+                    
+            class_name.constantize.collection.update(
+              { :_id => foreign_key_value }, 
+              { '$inc' =>  inc_options }
+            )
+          end
         end
+        
+        successed
       end
+      
     end
   
     # Make a vote on this votee
@@ -167,59 +180,35 @@ module Mongoid
     #   - :voter_id: the voter document id
     #   - :value: vote :up or vote :down
     def vote(options)
-      VOTE_POINT[self.class.name].each do |class_name, value_point|
-        next unless relation_metadata = relations[class_name.underscore]
-        next unless foreign_key = relation_metadata.foreign_key
-        options[foreign_key.to_sym] = read_attribute(foreign_key)
-      end
-      
       options[:votee_id] ||= _id
-      options[:revote] ||= !vote_value(options[:voter_id]).nil?
+      options[:votee] ||= self
 
-      self.class.vote(options)
-    end
-
-    # Cancel a vote on this votee
-    #
-    # @param [Hash] options a hash containings:
-    #   - :voter_id: the voter document id
-    def unvote(options)
-      VOTE_POINT[self.class.name].each do |class_name, value_point|
-        next unless relation_metadata = relations[class_name.underscore]
-        next unless foreign_key = relation_metadata.foreign_key
-        options[foreign_key.to_sym] = read_attribute(foreign_key)
+      if options[:unvote]
+        options[:value] ||= vote_value(options[:voter_id])
+      else
+        options[:revote] ||= !vote_value(options[:voter_id]).nil?
       end
-      
-      options[:votee_id] ||= _id
-      options[:value] = vote_value(options[:voter_id])
-      self.class.unvote(options)
+
+      self.class.vote(options)
     end
 
     # Get a voted value on this votee
     #
-    # @param [String, BSON::ObjectId] x the id of the voter who made the vote
-    def vote_value(x)
-      voter_id = case x
-      when String
-        BSON::ObjectId(x)
-      when BSON::ObjectId
-        x
-      else
-        x.id
-      end
-
+    # @param [Mongoid Object, BSON::ObjectId] voter is Mongoid object the id of the voter who made the vote
+    def vote_value(voter)
+      voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
       return :up if up_voter_ids.try(:include?, voter_id)
       return :down if down_voter_ids.try(:include?, voter_id)
     end
 
     # Get the number of up votes
     def up_votes_count
-      up_voter_ids.length
+      (up_voter_ids||[]).length
     end
     
     # Get the number of down votes
     def down_votes_count
-      down_voter_ids.length
+      (down_voter_ids||[]).length
     end
   end
-end
+end

data/lib/mongoid/voter.rb

@@ -5,7 +5,7 @@ module Mongoid
     # Get list of voted votees
     #
     # @param [Class] klass the votee class, e.g. `Post` or `Comment`
-    # @return [Array, nil] an array of votable objects voted by this voter
+    # @return [Array, nil] an array of voteable objects voted by this voter
     def votees(klass)
       klass.any_of({ :up_voter_ids => _id }, { :down_voter_ids => _id })
     end
@@ -22,7 +22,7 @@ module Mongoid
         votee = options[:votee]
         if votee
           votee_class = votee.class
-          votee_id = votee.id
+          votee_id = votee._id
         else
           votee_class = options[:votee_type].classify.constantize
           votee_id = options[:votee_id]
@@ -32,13 +32,6 @@ module Mongoid
       votees(votee_class).where(:_id => votee_id).count == 1
     end
 
-    # Cancel the vote on a votee
-    #
-    # @param [Object] votee the votee to be unvoted
-    def unvote(votee)
-      votee.unvote(:voter_id => _id)
-    end
-
     # Get the voted value on a votee
     #
     # @param (see #voted?)
@@ -47,38 +40,49 @@ module Mongoid
       votee = unless options.is_a?(Hash)
         options
       else
-        options[:votee_type].classify.constantize.only(:up_vote_ids, :down_vote_ids).where(
+        options[:votee] || options[:votee_type].classify.constantize.only(:up_vote_ids, :down_vote_ids).where(
           :_id => options[:votee_id]
         ).first
       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
-    def vote(options, vote_value = nil)
-      options.symbolize_keys!
-
-      if options.is_a?(Hash) 
+    # @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 => vote_value }
+        options = { :votee => votee, :value => value }
       end
 
       if votee
-        options[:votee_id] = votee.id
+        options[:votee_id] = votee._id
         votee_class = votee.class
       else
         votee_class = options[:votee_type].classify.constantize
       end
       
-      options[:revote] = if options.has_key?(:revote)
-        !options[:revote].blank?
+      if options[:value].nil?
+        options[:unvote] = true
+        options[:value] = vote_value(options)
       else
-        options.has_key?(:new) ? options[:new].blank? : voted?(options)
+        options[:revote] = options.has_key?(:revote) ? !options[:revote].blank? : voted?(options)
       end
       
       options[:voter_id] = _id
@@ -86,4 +90,4 @@ module Mongoid
       ( votee || votee_class ).vote(options)
     end
   end
-end
+end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: voteable_mongoid
 version: !ruby/object:Gem::Version 
-  hash: 13
   prerelease: 
-  segments: 
-  - 0
-  - 4
-  - 1
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors: 
 - Alex Nguyen
@@ -15,124 +10,64 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-23 00:00:00 +08:00
+date: 2011-03-01 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: voteable_mongoid
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  prerelease: false
   type: :runtime
-  requirement: *id001
-- !ruby/object:Gem::Dependency 
-  name: bson_ext
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
   prerelease: false
-  type: :development
-  requirement: *id002
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  prerelease: false
   type: :development
-  requirement: *id003
-- !ruby/object:Gem::Dependency 
-  name: bson_ext
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
   prerelease: false
-  type: :development
-  requirement: *id004
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  prerelease: false
   type: :development
-  requirement: *id005
+  prerelease: false
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: mongoid
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7712058
-        segments: 
-        - 2
-        - 0
-        - 0
-        - rc
         version: 2.0.0.rc
-  prerelease: false
   type: :runtime
-  requirement: *id006
-- !ruby/object:Gem::Dependency 
-  name: bson_ext
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
   prerelease: false
-  type: :development
-  requirement: *id007
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: rspec
-  version_requirements: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  prerelease: false
   type: :development
-  requirement: *id008
+  prerelease: false
+  version_requirements: *id005
 description: Add Up / Down Voting for Mongoid
 email: alex@vinova.sg
 executables: []
@@ -162,23 +97,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
 summary: Add Up / Down Voting for Mongoid