voteable_mongoid 0.7.0 → 0.7.1

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+== 0.7.1
+  * Refactor & cleanup source code
+  * Better doc
+  * Add votee#voted_by?(voter or voter_id)
+
 == 0.7.0
   * Use readable field names (up, down, up_count, down_count, count, point) instead of very short field names (u, d, uc, dc, c, p)
 

data/README.rdoc

@@ -60,12 +60,38 @@ user.rb
 
     @user.vote(@post, :up)
     # is equivalent to
-    @post.vote(:voter_id => @user.id, :value => :up)
+    @user.vote(:votee => @post, :value => :up)
+    @post.vote(:voter => @user, :value => :up)
 
-    # this will affect @post.votes_count and @post.votes_point as well
-    @user.vote(@comment, :down)
+    # In case you don't need to init voter and / or votee objects you can    
+    @user.vote(:votee_type => 'Post', :votee_id => post_id, :value => :down)
+    @post.vote(:voter_id => user_id, :value => :up)
+    Post.vote(:voter_id => user_id, :votee_id => post_id, :value => :up)
 
-=== Getting votes count and points
+=== Undo a vote
+
+    @user.unvote(@comment)
+
+=== If have full information you do not need to init voter and votee object
+
+    Post.vote(:voter_id => user_id, :votee_id => post_id, :value => :up, :revote => true)
+    Post.vote(:voter_id => user_id, :votee_id => post_id, :value => :up, :unvote => true)
+
+=== Getting vote_value
+    
+    @user.vote_value(@post)
+    @user.vote_value(:class_type => 'Post', :votee_id => post_id)
+    @post.vote_value(@user)
+    @post.vote_value(user_id)
+
+=== Check if voted?
+
+    @user.voted?(@post)
+    @user.voted?(:class_type => 'Post', :votee_id => post_id)
+    @post.voted_by?(@user)
+    @post.voted_by?(user_id)
+
+=== Getting votes counts and points
 
     puts @post.votes_point
     puts @post.votes_count
@@ -78,29 +104,25 @@ user.rb
     Post.up_voted_by(@user)
     Post.down_voted_by(@user)
 
-=== Undo a vote
-
-    @user.unvote(@comment)
-
 == Utilities
 
 === Re-generate counters and vote points in case you change :up / :down vote points
 Rails
     rake db:mongoid:voteable:remake_stats
 Ruby
-    Mongoid::Voteable::Stats.remake
+    Mongoid::Voteable::Tasks.remake_stats
 
 === Set counters and point to 0 for uninitialized voteable objects in order sort and query
 Rails
     rake db:mongoid:voteable:init_stats
 Ruby
-    Mongoid::Voteable::Stats.init
+    Mongoid::Voteable::Tasks::init_stats
 
 === Migrate from version < 0.7.0
 Rails
     rake db:mongoid:voteable:migrate_old_votes
 Ruby
-    Mongoid::Voteable.migrate_old_votes
+    Mongoid::Voteable::Tasks.migrate_old_votes
 
 == Credits
 

data/TODO

@@ -1,2 +1,2 @@
 * Option hash validations
-* Refactor Voteable#vote function
+

data/lib/voteable_mongoid.rb

@@ -1,10 +1,9 @@
 require 'mongoid'
-require 'voteable_mongoid/voteable/stats'
-require 'voteable_mongoid/voteable/votes'
 require 'voteable_mongoid/voteable'
 require 'voteable_mongoid/voter'
 
-# add railtie
+require 'voteable_mongoid/voteable/tasks'
+# Add railtie
 if defined?(Rails)
   require 'voteable_mongoid/railtie'
 end

data/lib/voteable_mongoid/railties/database.rake

@@ -3,17 +3,17 @@ namespace :db do
     namespace :voteable do
       desc 'Update up_votes_count, down_votes_count, votes_count and votes_point'
       task :remake_stats => :environment do
-        Mongoid::Voteable::Stats.remake(:log)
+        Mongoid::Voteable::Tasks.remake_stats(:log)
       end
       
       desc 'Set counters and point to 0 for uninitizized voteable objects'
       task :init_stats => :environment do
-        Mongoid::Voteable::Stats.init(:log)
+        Mongoid::Voteable::Tasks.init_stats(:log)
       end
       
-      desc 'Migrate vote data created by version < 0.6.0 to new vote data storage'
+      desc 'Migrate vote data created by version < 0.7.0 to new vote data storage'
       task :migrate_old_votes => :environment do
-        Mongoid::Voteable.migrate_old_votes(:log)
+        Mongoid::Voteable::Tasks.migrate_old_votes(:log)
       end
     end
   end

data/lib/voteable_mongoid/version.rb

@@ -1,3 +1,3 @@
 module VoteableMongoid
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/lib/voteable_mongoid/voteable.rb

@@ -1,236 +1,70 @@
+require 'voteable_mongoid/voteable/votes'
+require 'voteable_mongoid/voteable/voting'
+
 module Mongoid
   module Voteable
     extend ActiveSupport::Concern
 
-    # How many points should be assigned for each up or down vote.
-    # This hash should manipulated using voteable method
-    VOTEABLE = {}
-
     included do
-      include Mongoid::Document
-      include Mongoid::Voteable::Stats
-      field :votes, :type => Mongoid::Voteable::Votes
+      include Document
+      include Voting
+      
+      field :votes, :type => Votes
+
+      before_create do
+        # Init votes so that counters and point have numeric values (0)
+        self.votes = Votes::DEFAULT_ATTRIBUTES
+      end
       
       scope :voted_by, lambda { |voter|
-        voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
+        voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter.id
         any_of({ 'votes.up' => voter_id }, { 'votes.down' => voter_id })
       }
       
       scope :up_voted_by, lambda { |voter|
-        voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
+        voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter.id
         where( 'votes.up' => voter_id )
       }
       
       scope :down_voted_by, lambda { |voter|
-        voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
+        voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter.id
         where( 'votes.down' => voter_id )
       }
-      
-      before_create do
-        # Init votes so that counters and point have numeric values (0)
-        self.votes = VOTES_DEFAULT_ATTRIBUTES
-      end
-      
+    end # include
+    
+    # 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 self.voteable(klass = self, options = nil)
+      def voteable(klass = self, options = nil)
         VOTEABLE[self.name] ||= {}
         VOTEABLE[self.name][klass.name] ||= options
       end
-
-      # We usually need to show current_user his voting value on voteable object
-      # voting value can be nil (not voted yet), :up or :down
-      # from voting value, we can decide it should be new vote or revote with :up or :down
-      # In this case, validation can be skip to maximize performance
-
-      # 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: 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]
-        
-        votee_id = BSON::ObjectId(votee_id) if votee_id.is_a?(String)
-        voter_id = BSON::ObjectId(voter_id) if voter_id.is_a?(String)
-
-        klass = options[:class]
-        klass ||= VOTEABLE.keys.include?(name) ? name : collection.name.classify
-        voteable = VOTEABLE[klass][klass]
-        
-        if options[:revote]
-          if 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 = voteable[:up] - 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 = -voteable[:up] + voteable[:down]
-          end
-          
-          update_result = collection.update({ 
-            # Validate voter_id did a vote with value for votee_id
-            :_id => votee_id,
-            positive_voter_ids => { '$ne' => voter_id },
-            negative_voter_ids => voter_id
-          }, {
-            # then update
-            '$pull' => { negative_voter_ids => voter_id },
-            '$push' => { positive_voter_ids => voter_id },
-            '$inc' => {
-              positive_votes_count => +1,
-              negative_votes_count => -1,
-              'votes.point' => point_delta
-            }
-          }, {
-            :safe => true
-          })
-
-        elsif options[:unvote]
-          if 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
-          
-          # 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_voter_ids => { '$ne' => voter_id },
-            positive_voter_ids => voter_id
-          }, {
-            # then update
-            '$pull' => { positive_voter_ids => voter_id },
-            '$inc' => {
-              positive_votes_count => -1,
-              'votes.count' => -1,
-              'votes.point' => -voteable[value]
-            }
-          }, {
-            :safe => true
-          })
-          
-        else # new vote
-          if value.to_sym == :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
-
-          update_result = collection.update({ 
-            # Validate voter_id did not vote for votee_id yet
-            :_id => votee_id,
-            'votes.up' => { '$ne' => voter_id },
-            'votes.down' => { '$ne' => voter_id }
-          }, {
-            # then update
-            '$push' => { positive_voter_ids => voter_id },
-            '$inc' => {  
-              'votes.count' => +1,
-              positive_votes_count => +1,
-              'votes.point' => voteable[value] }
-          }, {
-            :safe => true
-          })
-        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 )
-
-        if successed
-          VOTEABLE[klass].each do |class_name, voteable|
-            # For other class in VOTEABLE options, if is parent of current class
-            next unless relation_metadata = relations[class_name.underscore]
-            next unless 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)
-          
-            inc_options = {}
-            
-            if options[:revote]
-              if 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[value]
-              unless voteable[:update_counters] == false
-                inc_options['votes.count'] = -1
-                if 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[value]
-              unless voteable[:update_counters] == false
-                inc_options['votes.count'] = +1
-                if value == :up
-                  inc_options['votes.up_count'] = +1
-                else
-                  inc_options['votes.down_count'] = +1
-                end
-              end
-            end
-                    
-            class_name.constantize.collection.update(
-              { :_id => foreign_key_value }, 
-              { '$inc' =>  inc_options }
-            )
-          end
-        end
-        true
-      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[: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]).nil?
+        options[:revote] ||= vote_value(options[:voter_id]).present?
       end
 
       self.class.vote(options)
@@ -240,19 +74,44 @@ module Mongoid
     #
     # @param [Mongoid Object, BSON::ObjectId] voter is Mongoid object or the id of the voter who made the vote
     def vote_value(voter)
-      voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
+      voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter.id
       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
+
+    # 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
+    
   end
 end

data/lib/voteable_mongoid/voteable/tasks.rb

@@ -0,0 +1,156 @@
+module Mongoid
+  module Voteable
+    module Tasks
+
+      # Set counters and point to 0 for uninitialized voteable objects 
+      # in order sort and query
+      def self.init_stats(log = false)
+        VOTEABLE.each do |class_name, voteable|
+          klass = class_name.constantize
+          klass_voteable = voteable[class_name]
+          puts "Init stats for #{class_name}" if log
+          klass.collection.update({:votes => nil}, {
+            '$set' => { :votes => Votes::DEFAULT_ATTRIBUTES }
+          }, {
+            :safe => true,
+            :multi => true
+          })
+        end
+      end
+      
+      # Re-generate vote counters and vote points
+      def self.remake_stats(log = false)
+        remake_stats_for_all_voteable_classes(log)
+        update_parent_stats(log)
+      end
+
+      # Convert votes from from version < 0.7.0 to new data store
+      def self.migrate_old_votes(log = false)
+        VOTEABLE.each do |class_name, voteable|
+          klass = class_name.constantize
+          klass_voteable = voteable[class_name]
+          puts "* Migrating old vote data for #{class_name} ..." if log
+          migrate_old_votes_for(klass, klass_voteable)
+        end
+      end
+
+      def self.migrate_old_votes_for(klass, voteable)
+        klass.all.each do |doc|
+          # Version 0.6.x use very short field names (u, d, uc, dc, c, p) to minimize 
+          # votes storage but it's not human friendly
+          # Version >= 0.7.0 use readable field names (up, down, up_count, down_count,
+          # count, point)
+          votes = doc['votes'] || doc['voteable'] || {}
+
+          up_voter_ids = votes['u'] || votes['up'] || 
+            votes['up_voter_ids'] || doc['up_voter_ids'] || []
+
+          down_voter_ids = votes['d'] || votes['down'] || 
+            votes['down_voter_ids'] || doc['down_voter_ids'] || []
+
+          up_count = up_voter_ids.size
+          down_count = down_voter_ids.size
+
+          klass.collection.update({ :_id => doc.id }, {
+            '$set' => {
+                'votes' => {
+                  'up' => up_voter_ids,
+                  'down' => down_voter_ids,
+                  'up_count' => up_count,
+                  'down_count' => down_count,
+                  'count' => up_count + down_count,
+                  'point' => voteable[:up]*up_count + voteable[:down]*down_count
+                }
+            },
+            '$unset' => {
+              'up_voter_ids' => true,
+              'down_voter_ids' => true,
+              'votes_count' => true,
+              'votes_point' => true,
+              'voteable' => true
+            }
+          }, { :safe => true })
+        end
+      end
+      
+        
+      def self.remake_stats_for_all_voteable_classes(log)
+        VOTEABLE.each do |class_name, voteable|
+          klass = class_name.constantize
+          klass_voteable = voteable[class_name]
+          puts "Generating stats for #{class_name}" if log
+          klass.all.each{ |doc|
+            remake_stats_for(doc, klass_voteable)
+          }
+        end
+      end
+
+  
+      def self.remake_stats_for(doc, voteable)
+        up_count = doc.up_voter_ids.length
+        down_count = doc.down_voter_ids.length
+    
+        doc.update_attributes(
+          'votes.up_count' => up_count,
+          'votes.down_count' => down_count,
+          'votes.count' => up_count + down_count,
+          'votes.point' => voteable[:up]*up_count + voteable[:down]*down_count
+        )
+      end
+
+
+      def self.update_parent_stats(log)
+        VOTEABLE.each do |class_name, voteable|
+          klass = class_name.constantize
+          voteable.each do |parent_class_name, parent_voteable|
+            relation_metadata = klass.relations[parent_class_name.underscore]
+            if relation_metadata
+              parent_class = parent_class_name.constantize
+              foreign_key = relation_metadata.foreign_key
+              puts "Updating stats for #{class_name} > #{parent_class_name}" if log
+              klass.all.each{ |doc|
+                update_parent_stats_for(doc, parent_class, foreign_key, parent_voteable)
+              }
+            end
+          end
+        end
+      end
+  
+  
+      def self.update_parent_stats_for(doc, parent_class, foreign_key, voteable)
+        parent_id = doc.read_attribute(foreign_key.to_sym)
+        if parent_id
+          up_count = doc.up_voter_ids.length
+          down_count = doc.down_voter_ids.length
+      
+          return if up_count == 0 && down_count == 0
+
+          inc_options = {
+            'votes.point' => voteable[:up]*up_count + voteable[:down]*down_count
+          }
+        
+          unless voteable[:update_counters] == false
+            inc_options.merge!(
+              'votes.count' => up_count + down_count,
+              'votes.up_count' => up_count,
+              'votes.down_count' => down_count
+            )
+          end
+      
+          parent_class.collection.update(
+            { '_id' => parent_id }, 
+            { '$inc' =>  inc_options },
+            { :safe => true }
+          )
+        end
+      end
+
+      private_class_method  :migrate_old_votes_for, 
+                            :remake_stats_for,
+                            :remake_stats_for_all_voteable_classes,
+                            :update_parent_stats,
+                            :update_parent_stats_for                            
+      
+    end
+  end
+end

data/lib/voteable_mongoid/voteable/votes.rb

@@ -3,56 +3,16 @@ module Mongoid
     
     class Votes
       include Mongoid::Document
+
       field :up, :type => Array, :default => []
       field :down, :type => Array, :default => []
       field :up_count, :type => Integer, :default => 0
       field :down_count, :type => Integer, :default => 0
       field :count, :type => Integer, :default => 0
       field :point, :type => Integer, :default => 0
-    end
-    
-    VOTES_DEFAULT_ATTRIBUTES = Votes.new.attributes
-    VOTES_DEFAULT_ATTRIBUTES.delete('_id')
-    
-    def self.migrate_old_votes(log = false)
-      VOTEABLE.each do |class_name, voteable|
-        klass = class_name.constantize
-        klass_voteable = voteable[class_name]
-        puts "* Migrating old vote data for #{class_name} ..." if log
 
-        klass.all.each do |doc|
-          # Version 0.6.x use very short field names (u, d, uc, dc, c, p) to minimize 
-          # votes storage but it's not human friendly
-          # Version >= 0.7.0 use readable field names (up, down, up_count, down_count,
-          # count, point)
-          votes = doc['votes'] || doc['voteable'] || {}
-          up_voter_ids = votes['u'] || votes['up'] || votes['up_voter_ids'] || doc['up_voter_ids'] || []
-          down_voter_ids = votes['d'] || votes['down'] || votes['down_voter_ids'] || doc['down_voter_ids'] || []
-          
-          up_count = up_voter_ids.size
-          down_count = down_voter_ids.size
-          
-          klass.collection.update({ :_id => doc.id }, {
-            '$set' => {
-                'votes' => {
-                  'up' => up_voter_ids,
-                  'down' => down_voter_ids,
-                  'up_count' => up_count,
-                  'down_count' => down_count,
-                  'count' => up_count + down_count,
-                  'point' => klass_voteable[:up]*up_count + klass_voteable[:down]*down_count
-                }
-            },
-            '$unset' => {
-              'up_voter_ids' => true,
-              'down_voter_ids' => true,
-              'votes_count' => true,
-              'votes_point' => true,
-              'voteable' => true
-            }
-          })
-        end
-      end
+      DEFAULT_ATTRIBUTES = new.attributes
+      DEFAULT_ATTRIBUTES.delete('_id')
     end
     
   end

data/lib/voteable_mongoid/voteable/voting.rb

@@ -0,0 +1,202 @@
+module Mongoid
+  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: change from vote up to vote down
+        #   - :unvote: unvote the vote value (:up or :down)
+        def vote(options)
+          options.symbolize_keys!
+          options[:votee_id] = BSON::ObjectId(options[:votee_id]) if options[:votee_id].is_a?(String)
+          options[:voter_id] = BSON::ObjectId(options[:voter_id]) if options[:voter_id].is_a?(String)
+          options[:value] = options[:value].to_sym
+          options[:voteable] = VOTEABLE[name][name]
+          
+          update_parents = true
+
+          if options[:voteable]
+            update_result = if options[:revote]
+              revote(options)
+            elsif options[:unvote]
+              unvote(options)
+            else
+              new_vote(options)
+            end
+            # Only update parent votes if votee is updated successfully
+            update_parents = ( update_result['err'] == nil and 
+              update_result['updatedExisting'] == true and
+              update_result['n'] == 1 )
+          end
+
+          update_parent_votes(options) if update_parents
+        end
+
+        
+        private
+          def new_vote(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
+
+            collection.update({ 
+              # 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]] }
+            }, {
+              :safe => true
+            })
+          end
+
+          
+          def revote(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
+
+            collection.update({ 
+              # Validate voter_id did a vote with value for votee_id
+              :_id => options[:votee_id],
+              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
+              }
+            }, {
+              :safe => true
+            })
+          end
+          
+
+          def unvote(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
+
+            # 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 => options[:votee_id],
+              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]]
+              }
+            }, {
+              :safe => true
+            })
+          end
+          
+
+          def update_parent_votes(options)
+            value = options[:value]
+            votee ||= options[:votee]
+            
+            VOTEABLE[name].each do |class_name, voteable|
+              # For other class in VOTEABLE options, if is parent of current class
+              next unless relation_metadata = relations[class_name.underscore]
+              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)
+
+              class_name.constantize.collection.update(
+                { '_id' => foreign_key_value }, 
+                { '$inc' => parent_inc_options(value, voteable, options) }
+              )
+            end
+          end
+
+          
+          def parent_inc_options(value, voteable, options)
+            inc_options = {}
+
+            if options[:revote]
+              if 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[value]
+              unless voteable[:update_counters] == false
+                inc_options['votes.count'] = -1
+                if 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[value]
+              unless voteable[:update_counters] == false
+                inc_options['votes.count'] = +1
+                if 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_mongoid/voter.rb

@@ -9,12 +9,12 @@ module Mongoid
     def voted?(options)
       unless options.is_a?(Hash)
         votee_class = options.class
-        votee_id = options._id
+        votee_id = options.id
       else
         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]
@@ -64,7 +64,7 @@ module Mongoid
       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
@@ -77,7 +77,8 @@ module Mongoid
         options[:revote] = options.has_key?(:revote) ? !options[:revote].blank? : voted?(options)
       end
       
-      options[:voter_id] = _id
+      options[:voter] = self
+      options[:voter_id] = id
 
       ( votee || votee_class ).vote(options)
     end

data/spec/spec_helper.rb

@@ -26,6 +26,6 @@ end
 
 Dir[ File.join(MODELS, "*.rb") ].sort.each { |file| require File.basename(file) }
 
-
-RSpec.configure do |config|
-end
+User.collection.drop
+Post.collection.drop
+Comment.collection.drop

data/spec/voteable_mongoid/voteable_spec.rb

@@ -2,8 +2,6 @@ require "spec_helper"
 
 describe Mongoid::Voteable do
   before :all do
-    Mongoid::database.connection.drop_database(Mongoid::database.name)
-
     @post1 = Post.create!
     @post2 = Post.create!
     
@@ -38,9 +36,9 @@ describe Mongoid::Voteable do
       Post.voted_by(@user2).should be_empty
     end
     
-    it 'test Stats.init' do
-      @post1.votes.should == Mongoid::Voteable::VOTES_DEFAULT_ATTRIBUTES
-      @post2.votes.should == Mongoid::Voteable::VOTES_DEFAULT_ATTRIBUTES
+    it 'test init stats' do
+      @post1.votes.should == Mongoid::Voteable::Votes::DEFAULT_ATTRIBUTES
+      @post2.votes.should == Mongoid::Voteable::Votes::DEFAULT_ATTRIBUTES
       
       @post1.votes = nil
       @post1.save
@@ -48,17 +46,17 @@ describe Mongoid::Voteable do
       @post2.votes = nil
       @post2.save
       
-      Mongoid::Voteable::Stats.init
+      Mongoid::Voteable::Tasks.init_stats
 
       @post1.reload
       @post2.reload
       
-      @post1.votes.should == Mongoid::Voteable::VOTES_DEFAULT_ATTRIBUTES
-      @post2.votes.should == Mongoid::Voteable::VOTES_DEFAULT_ATTRIBUTES
+      @post1.votes.should == Mongoid::Voteable::Votes::DEFAULT_ATTRIBUTES
+      @post2.votes.should == Mongoid::Voteable::Votes::DEFAULT_ATTRIBUTES
     end
     
     it 'revote has no effect' do
-      Post.vote(:revote => true, :votee_id => @post1.id, :voter_id => @user1.id, :value => 'up')
+      @post1.vote(:revote => true, :voter => @user1, :value => 'up')
       @post1.reload
 
       @post1.up_votes_count.should == 0
@@ -89,7 +87,9 @@ describe Mongoid::Voteable do
       @post1.votes_point.should == 1
 
       @post1.vote_value(@user1).should == :up
+      @post1.should be_voted_by(@user1)
       @post1.vote_value(@user2.id).should be_nil
+      @post1.should_not be_voted_by(@user2.id)
 
       Post.voted_by(@user1).to_a.should == [ @post1 ]
       Post.voted_by(@user2).to_a.should be_empty
@@ -131,7 +131,7 @@ describe Mongoid::Voteable do
   context 'user1 change vote on post1 from up to down' do
     before :all do
       Post.vote(:revote => true, :votee_id => @post1.id, :voter_id => @user1.id, :value => :down)
-      Mongoid::Voteable::Stats.remake
+      Mongoid::Voteable::Tasks.remake_stats
       @post1.reload
     end
     
@@ -171,7 +171,7 @@ describe Mongoid::Voteable do
   context 'user1 change vote on post2 from down to up' do
     before :all do
       Post.vote(:revote => true, :votee_id => @post2.id.to_s, :voter_id => @user1.id.to_s, :value => :up)
-      Mongoid::Voteable::Stats.remake
+      Mongoid::Voteable::Tasks.remake_stats
       @post2.reload
     end
     
@@ -247,7 +247,7 @@ describe Mongoid::Voteable do
   context "user1 unvote on post1" do
     before(:all) do
       @post1.vote(:voter_id => @user1.id, :votee_id => @post1.id, :unvote => true)
-      Mongoid::Voteable::Stats.remake
+      Mongoid::Voteable::Tasks.remake_stats
       @post1.reload
     end
     
@@ -283,7 +283,7 @@ describe Mongoid::Voteable do
   context "user1 unvote on comment" do
     before(:all) do
       @user1.unvote(@comment)
-      Mongoid::Voteable::Stats.remake
+      Mongoid::Voteable::Tasks.remake_stats
       @comment.reload
       @post2.reload
     end
@@ -303,7 +303,7 @@ describe Mongoid::Voteable do
   
   context 'final' do
     it "test remake stats" do
-      Mongoid::Voteable::Stats.remake
+      Mongoid::Voteable::Tasks.remake_stats
 
       @post1.up_votes_count.should == 0
       @post1.down_votes_count.should == 1

data/spec/voteable_mongoid/voter_spec.rb

@@ -2,8 +2,6 @@ require "spec_helper"
 
 describe Mongoid::Voter do
   before :all do
-    Mongoid::database.connection.drop_database(Mongoid::database.name)
-
     @post1 = Post.create!
     @post2 = Post.create!
 

data/voteable_mongoid.gemspec

@@ -15,8 +15,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'mongoid', '~> 2.0.0'
   
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'bson_ext'
-  s.add_development_dependency 'watchr'
 
   s.rubyforge_project = "voteable_mongoid"
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: voteable_mongoid
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 0
   - 7
-  - 0
-  version: 0.7.0
+  - 1
+  version: 0.7.1
 platform: ruby
 authors: 
 - Alex Nguyen
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-02 00:00:00 +08:00
-default_executable: 
+date: 2011-04-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: mongoid
@@ -48,34 +47,6 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bson_ext
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: watchr
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id004
 description: Add Up / Down Voting for Mongoid (built for speed by using one Mongodb update-in-place for each collection when provided enough information)
 email: 
 - alex@vinova.sg
@@ -98,8 +69,9 @@ files:
 - lib/voteable_mongoid/railties/database.rake
 - lib/voteable_mongoid/version.rb
 - lib/voteable_mongoid/voteable.rb
-- lib/voteable_mongoid/voteable/stats.rb
+- lib/voteable_mongoid/voteable/tasks.rb
 - lib/voteable_mongoid/voteable/votes.rb
+- lib/voteable_mongoid/voteable/voting.rb
 - lib/voteable_mongoid/voter.rb
 - spec/.rspec
 - spec/models/comment.rb
@@ -109,7 +81,6 @@ files:
 - spec/voteable_mongoid/voteable_spec.rb
 - spec/voteable_mongoid/voter_spec.rb
 - voteable_mongoid.gemspec
-has_rdoc: true
 homepage: https://github.com/vinova/voteable_mongoid
 licenses: []
 
@@ -139,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: voteable_mongoid
-rubygems_version: 1.6.2
+rubygems_version: 1.7.1
 signing_key: 
 specification_version: 3
 summary: Add Up / Down Voting for Mongoid

data/lib/voteable_mongoid/voteable/stats.rb

@@ -1,115 +0,0 @@
-module Mongoid
-  module Voteable
-    module Stats
-      extend ActiveSupport::Concern
-
-      # 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
-      
-      def self.init(log = false)
-        VOTEABLE.each do |class_name, voteable|
-          klass = class_name.constantize
-          klass_voteable = voteable[class_name]
-          puts "Init stats for #{class_name}" if log
-          klass.collection.update({:votes => nil}, {
-            '$set' => { :votes => VOTES_DEFAULT_ATTRIBUTES }
-          }, {
-            :safe => true,
-            :multi => true
-          })
-        end
-      end
-      
-      # Re-generate vote counters and vote points
-      def self.remake(log = false)
-        remake_stats(log)
-        update_parent_stats(log)
-      end
-      
-      def self.remake_stats(log)
-        VOTEABLE.each do |class_name, voteable|
-          klass = class_name.constantize
-          klass_voteable = voteable[class_name]
-          puts "Generating stats for #{class_name}" if log
-          klass.all.each{ |doc|
-            doc.remake_stats(klass_voteable)
-          }
-        end
-      end
-      
-      def remake_stats(voteable)
-        up_count = up_voter_ids.length
-        down_count = down_voter_ids.length
-        
-        update_attributes(
-          'votes.up_count' => up_count,
-          'votes.down_count' => down_count,
-          'votes.count' => up_count + down_count,
-          'votes.point' => voteable[:up]*up_count + voteable[:down]*down_count
-        )
-      end
-    
-      def self.update_parent_stats(log)
-        VOTEABLE.each do |class_name, voteable|
-          klass = class_name.constantize
-          voteable.each do |parent_class_name, parent_voteable|
-            relation_metadata = klass.relations[parent_class_name.underscore]
-            if relation_metadata
-              parent_class = parent_class_name.constantize
-              foreign_key = relation_metadata.foreign_key
-              puts "Updating stats for #{class_name} > #{parent_class_name}" if log
-              klass.all.each{ |doc|
-                doc.update_parent_stats(parent_class, foreign_key, parent_voteable)
-              }
-            end
-          end
-        end
-      end
-      
-      def update_parent_stats(parent_class, foreign_key, voteable)
-        parent_id = read_attribute(foreign_key.to_sym)
-        if parent_id
-          up_count = up_voter_ids.length
-          down_count = down_voter_ids.length
-        
-          return if up_count == 0 && down_count == 0
-
-          inc_options = {
-            'votes.point' => voteable[:up]*up_count + voteable[:down]*down_count
-          }
-          
-          unless voteable[:update_counters] == false
-            inc_options.merge!(
-              'votes.count' => up_count + down_count,
-              'votes.up_count' => up_count,
-              'votes.down_count' => down_count
-            )
-          end
-        
-          parent_class.collection.update(
-            { '_id' => parent_id }, 
-            { '$inc' =>  inc_options }
-          )
-        end
-      end
-      
-    end
-  end
-end