voteable_mongo 0.8.1

data/lib/voteable_mongo/voteable/tasks.rb

@@ -0,0 +1,162 @@
+module Mongo
+  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['up'] || votes['u'] ||
+            votes['up_voter_ids'] || doc['up_voter_ids'] || []
+
+          down_voter_ids = votes['down'] || votes['d'] ||
+            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].to_i*up_count + voteable[:down].to_i*down_count
+                }
+            },
+            '$unset' => {
+              'up_voter_ids' => true,
+              'down_voter_ids' => true,
+              'votes_count' => true,
+              'votes_point' => true,
+              'voteable' => true
+              # 'votes.u' => true,
+              # 'votes.d' => true,
+              # 'votes.uc' => true,
+              # 'votes.dc' => true,
+              # 'votes.c' => true,
+              # 'votes.p' => 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].to_i*up_count + voteable[:down].to_i*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].to_i*up_count + voteable[:down].to_i*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_mongo/voteable/votes.rb

@@ -0,0 +1,19 @@
+module Mongo
+  module Voteable
+    
+    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
+
+      DEFAULT_ATTRIBUTES = new.attributes
+      DEFAULT_ATTRIBUTES.delete('_id')
+    end
+    
+  end
+end

data/lib/voteable_mongo/voteable/voting.rb

@@ -0,0 +1,229 @@
+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: if true always return updated voteable object
+        # 
+        # @return [votes, false, nil]
+        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
+
+            if options[:voteable][:update_parents] || options[:votee] || options[:return_votee]
+              # If votee exits or need to update parent
+              # use Collection#find_and_modify to retrieve updated votes data and parent_ids
+              begin
+                doc = collection.master.collection.find_and_modify(
+                  :query => query,
+                  :update => update,
+                  :new => true
+                )
+                # Update new votes data
+                options[:votee].write_attribute('votes', doc['votes']) if options[:votee]
+                update_parent_votes(doc, options) if options[:voteable][:update_parents]
+                return options[:votee] || new(doc)
+              rescue Exception => e
+                # $stderr.puts "Mongo error: #{e.inspect}" # DEBUG
+                # Don't update parents if operation fail or no matched object found
+                return false
+              end
+            else
+              # Just update and don't care the result
+              collection.update(query, update)
+            end
+          end
+        end
+
+        
+        private
+          def validate_and_normalize_vote_options(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
+          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|
+              # For other class in VOTEABLE options, if has relationship with current class
+              relation_metadata = relations.find{ |x, r| r.class_name == class_name }.try(:last)
+              next unless relation_metadata.present?
+
+              # If cannot find current votee foreign_key value for that class
+              foreign_key_value = doc[relation_metadata.foreign_key.to_s]
+              next unless foreign_key_value.present?
+
+              if relation_metadata.relation == ::Mongoid::Relations::Referenced::In
+                class_name.constantize.collection.update( 
+                  { '_id' => foreign_key_value },
+                  { '$inc' => parent_inc_options(voteable, options) }
+                )
+              elsif relation_metadata.relation == ::Mongoid::Relations::Referenced::ManyToMany
+                class_name.constantize.collection.update( 
+                  { '_id' => { '$in' => foreign_key_value } },
+                  { '$inc' => parent_inc_options(voteable, options) },
+                  { :multi => true }
+                )
+              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/voter.rb

@@ -0,0 +1,97 @@
+module Mongo
+  module Voter
+    extend ActiveSupport::Concern
+
+    included do
+      include ::Mongoid::Document
+
+      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
+
+    module InstanceMethods
+      # 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_type].classify.constantize
+            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_type].classify.constantize.only(:votes).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, 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_type].classify.constantize
+        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
+end