voteable_mongoid 0.6.4 → 0.7.0

data/CHANGELOG.rdoc

@@ -1,15 +1,18 @@
+== 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)
+
 == 0.6.4
   * Drop Voter#votees, Voter#up_votees, Voter#down_votees in favor of Voteable#voted_by(voter), Voteable#up_voted_by(voter), Voteable#down_voted_by(voter) scopes
-  
+
 == 0.6.3
   * Add rake db:mongoid:voteable:migrate_old_votes to migrate vote data created by version < 0.6.0 to new vote data storage
 
 == 0.6.2
   * Fix bug: use before_create instead of after_after_initialize
-  
+
 == 0.6.1
   * Set counters and point to 0 for uninitialized voteable objects in order sort and query
-  
+
 == 0.6.0
   * Minimize vote data store (using short field names votes.u, votes.d, votes.c ...)
   * Add Voter#up_votees, Voter#down_votees
@@ -18,15 +21,15 @@
 
 == 0.5.0
   * Rename vote_point to voteable
-  
+
 == 0.4.5
   * Can use rake db:mongoid:voteable:remake_stats in Rails apps
   * Use mongoid 2.0.0
-  
+
 == 0.4.4
   * Add up_votes_count, down_votes_count
   * Re-generate vote statistic data (counters and point)
- 
+
 == 0.4.3
   * Wrap vote data in voteable namespace (voteable.up_voters_id, voteable.down_voters_ids, voteable.votes_count ...)
 

data/README.rdoc

@@ -3,8 +3,7 @@
 Voteable Mongoid allows you to make your Mongoid::Document objects voteable (up or down).
 For instance, in a forum, a user can vote up (or down) on a post or a comment.
 
-Voteable Mongoid is built for speed. It minimizes vote data storage and uses 
-only one database request per collection to do both data validation and data update.
+Voteable Mongoid is built for speed. It uses only one database request per collection to do both data validation and data update.
 
 Sample app at https://github.com/vinova/simple_qa
 
@@ -97,7 +96,7 @@ Rails
 Ruby
     Mongoid::Voteable::Stats.init
 
-=== Migrate from version < 0.6.0
+=== Migrate from version < 0.7.0
 Rails
     rake db:mongoid:voteable:migrate_old_votes
 Ruby

data/lib/voteable_mongoid/version.rb

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

data/lib/voteable_mongoid/voteable.rb

@@ -13,17 +13,17 @@ module Mongoid
       
       scope :voted_by, lambda { |voter|
         voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
-        any_of({ UP_VOTER_IDS => voter_id }, { DOWN_VOTER_IDS => 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
-        where( UP_VOTER_IDS => voter_id )
+        where( 'votes.up' => voter_id )
       }
       
       scope :down_voted_by, lambda { |voter|
         voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter._id
-        where( DOWN_VOTER_IDS => voter_id )
+        where( 'votes.down' => voter_id )
       }
       
       before_create do
@@ -67,21 +67,21 @@ module Mongoid
 
         klass = options[:class]
         klass ||= VOTEABLE.keys.include?(name) ? name : collection.name.classify
-        value_point = VOTEABLE[klass][klass]
+        voteable = VOTEABLE[klass][klass]
         
         if options[:revote]
           if value == :up
-            positive_voter_ids = UP_VOTER_IDS
-            negative_voter_ids = DOWN_VOTER_IDS
-            positive_votes_count = UP_VOTES_COUNT
-            negative_votes_count = DOWN_VOTES_COUNT
-            point_delta = value_point[:up] - value_point[:down]
+            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 = DOWN_VOTER_IDS
-            negative_voter_ids = UP_VOTER_IDS
-            positive_votes_count = DOWN_VOTES_COUNT
-            negative_votes_count = UP_VOTES_COUNT
-            point_delta = -value_point[:up] + value_point[:down]
+            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({ 
@@ -96,7 +96,7 @@ module Mongoid
             '$inc' => {
               positive_votes_count => +1,
               negative_votes_count => -1,
-              VOTES_POINT => point_delta
+              'votes.point' => point_delta
             }
           }, {
             :safe => true
@@ -104,13 +104,13 @@ module Mongoid
 
         elsif options[:unvote]
           if value == :up
-            positive_voter_ids = UP_VOTER_IDS
-            negative_voter_ids = DOWN_VOTER_IDS
-            positive_votes_count = UP_VOTES_COUNT
+            positive_voter_ids = 'votes.up'
+            negative_voter_ids = 'votes.down'
+            positive_votes_count = 'votes.up_count'
           else
-            positive_voter_ids = DOWN_VOTER_IDS
-            negative_voter_ids = UP_VOTER_IDS
-            positive_votes_count = DOWN_VOTES_COUNT
+            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
@@ -124,8 +124,8 @@ module Mongoid
             '$pull' => { positive_voter_ids => voter_id },
             '$inc' => {
               positive_votes_count => -1,
-              VOTES_COUNT => -1,
-              VOTES_POINT => -value_point[value]
+              'votes.count' => -1,
+              'votes.point' => -voteable[value]
             }
           }, {
             :safe => true
@@ -133,25 +133,25 @@ module Mongoid
           
         else # new vote
           if value.to_sym == :up
-            positive_voter_ids = UP_VOTER_IDS
-            positive_votes_count = UP_VOTES_COUNT
+            positive_voter_ids = 'votes.up'
+            positive_votes_count = 'votes.up_count'
           else
-            positive_voter_ids = DOWN_VOTER_IDS
-            positive_votes_count = DOWN_VOTES_COUNT
+            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,
-            UP_VOTER_IDS => { '$ne' => voter_id },
-            DOWN_VOTER_IDS => { '$ne' => voter_id }
+            'votes.up' => { '$ne' => voter_id },
+            'votes.down' => { '$ne' => voter_id }
           }, {
             # then update
             '$push' => { positive_voter_ids => voter_id },
             '$inc' => {  
-              VOTES_COUNT => +1,
+              'votes.count' => +1,
               positive_votes_count => +1,
-              VOTES_POINT => value_point[value] }
+              'votes.point' => voteable[value] }
           }, {
             :safe => true
           })
@@ -163,7 +163,7 @@ module Mongoid
           update_result['n'] == 1 )
 
         if successed
-          VOTEABLE[klass].each do |class_name, value_point|
+          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])
@@ -174,36 +174,36 @@ module Mongoid
             
             if options[:revote]
               if value == :up
-                inc_options[VOTES_POINT] = value_point[:up] - value_point[:down]
-                unless value_point[:update_counters] == false
-                  inc_options[UP_VOTES_COUNT] = +1
-                  inc_options[DOWN_VOTES_COUNT] = -1
+                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] = -value_point[:up] + value_point[:down]
-                unless value_point[:update_counters] == false
-                  inc_options[UP_VOTES_COUNT] = -1
-                  inc_options[DOWN_VOTES_COUNT] = +1
+                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] = -value_point[value]
-              unless value_point[:update_counters] == false
-                inc_options[VOTES_COUNT] = -1
+              inc_options['votes.point'] = -voteable[value]
+              unless voteable[:update_counters] == false
+                inc_options['votes.count'] = -1
                 if value == :up
-                  inc_options[UP_VOTES_COUNT] = -1
+                  inc_options['votes.up_count'] = -1
                 else
-                  inc_options[DOWN_VOTES_COUNT] = -1
+                  inc_options['votes.down_count'] = -1
                 end
               end
             else # new vote
-              inc_options[VOTES_POINT] = value_point[value]
-              unless value_point[:update_counters] == false
-                inc_options[VOTES_COUNT] = 1
+              inc_options['votes.point'] = voteable[value]
+              unless voteable[:update_counters] == false
+                inc_options['votes.count'] = +1
                 if value == :up
-                  inc_options[UP_VOTES_COUNT] = 1
+                  inc_options['votes.up_count'] = +1
                 else
-                  inc_options[DOWN_VOTES_COUNT] = 1
+                  inc_options['votes.down_count'] = +1
                 end
               end
             end
@@ -247,12 +247,12 @@ module Mongoid
 
     # Array of up voter ids
     def up_voter_ids
-      votes.try(:[], 'u') || []
+      votes.try(:[], 'up') || []
     end
     
     # Array of down voter ids
     def down_voter_ids
-      votes.try(:[], 'd') || []
+      votes.try(:[], 'down') || []
     end
   end
 end

data/lib/voteable_mongoid/voteable/stats.rb

@@ -5,28 +5,28 @@ module Mongoid
 
       # Get the number of up votes
       def up_votes_count
-        votes.try(:[], 'uc') || 0
+        votes.try(:[], 'up_count') || 0
       end
     
       # Get the number of down votes
       def down_votes_count
-        votes.try(:[], 'dc') || 0
+        votes.try(:[], 'down_count') || 0
       end
     
       # Get the number of votes
       def votes_count
-        votes.try(:[], 'c') || 0
+        votes.try(:[], 'count') || 0
       end
     
       # Get the votes point
       def votes_point
-        votes.try(:[], 'p') || 0
+        votes.try(:[], 'point') || 0
       end
       
       def self.init(log = false)
-        VOTEABLE.each do |class_name, value_point|
+        VOTEABLE.each do |class_name, voteable|
           klass = class_name.constantize
-          klass_value_point = value_point[class_name]
+          klass_voteable = voteable[class_name]
           puts "Init stats for #{class_name}" if log
           klass.collection.update({:votes => nil}, {
             '$set' => { :votes => VOTES_DEFAULT_ATTRIBUTES }
@@ -44,46 +44,46 @@ module Mongoid
       end
       
       def self.remake_stats(log)
-        VOTEABLE.each do |class_name, value_point|
+        VOTEABLE.each do |class_name, voteable|
           klass = class_name.constantize
-          klass_value_point = value_point[class_name]
+          klass_voteable = voteable[class_name]
           puts "Generating stats for #{class_name}" if log
           klass.all.each{ |doc|
-            doc.remake_stats(klass_value_point)
+            doc.remake_stats(klass_voteable)
           }
         end
       end
       
-      def remake_stats(value_point)
+      def remake_stats(voteable)
         up_count = up_voter_ids.length
         down_count = down_voter_ids.length
         
         update_attributes(
-          UP_VOTES_COUNT => up_count,
-          DOWN_VOTES_COUNT => down_count,          
-          VOTES_COUNT => up_count + down_count,
-          VOTES_POINT => value_point[:up]*up_count + value_point[:down]*down_count
+          '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, value_point|
+        VOTEABLE.each do |class_name, voteable|
           klass = class_name.constantize
-          value_point.each do |parent_class_name, parent_value_point|
+          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_value_point)
+                doc.update_parent_stats(parent_class, foreign_key, parent_voteable)
               }
             end
           end
         end
       end
       
-      def update_parent_stats(parent_class, foreign_key, value_point)
+      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
@@ -92,19 +92,19 @@ module Mongoid
           return if up_count == 0 && down_count == 0
 
           inc_options = {
-            VOTES_POINT => value_point[:up]*up_count + value_point[:down]*down_count
+            'votes.point' => voteable[:up]*up_count + voteable[:down]*down_count
           }
           
-          unless value_point[:update_counters] == false
+          unless voteable[:update_counters] == false
             inc_options.merge!(
-              VOTES_COUNT => up_count + down_count,
-              UP_VOTES_COUNT => up_count,
-              DOWN_VOTES_COUNT => down_count
+              'votes.count' => up_count + down_count,
+              'votes.up_count' => up_count,
+              'votes.down_count' => down_count
             )
           end
         
           parent_class.collection.update(
-            { :_id => parent_id }, 
+            { '_id' => parent_id }, 
             { '$inc' =>  inc_options }
           )
         end

data/lib/voteable_mongoid/voteable/votes.rb

@@ -3,57 +3,55 @@ module Mongoid
     
     class Votes
       include Mongoid::Document
-      field :u, :type => Array, :default => []
-      field :d, :type => Array, :default => []
-      field :uc, :type => Integer, :default => 0
-      field :dc, :type => Integer, :default => 0
-      field :c, :type => Integer, :default => 0
-      field :p, :type => Integer, :default => 0
+      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
-
-    UP_VOTER_IDS      = 'votes.u'
-    DOWN_VOTER_IDS    = 'votes.d'
-    UP_VOTES_COUNT    = 'votes.uc'
-    DOWN_VOTES_COUNT  = 'votes.dc'
-    VOTES_COUNT       = 'votes.c'
-    VOTES_POINT       = 'votes.p'
     
     VOTES_DEFAULT_ATTRIBUTES = Votes.new.attributes
     VOTES_DEFAULT_ATTRIBUTES.delete('_id')
     
     def self.migrate_old_votes(log = false)
-      VOTEABLE.each do |class_name, value_point|
+      VOTEABLE.each do |class_name, voteable|
         klass = class_name.constantize
-        klass_value_point = value_point[class_name]
+        klass_voteable = voteable[class_name]
         puts "* Migrating old vote data for #{class_name} ..." if log
-        count = 0
+
         klass.all.each do |doc|
-          next if doc['votes']
-          count += 1
-          up_voter_ids = doc['up_voter_ids'] || []
-          down_voter_ids = doc['down_voter_ids'] || []
+          # 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 => {
-                  :u => doc.up_voter_ids,
-                  :d => doc.down_voter_ids,
-                  :uc => up_count,
-                  :dc => down_count,
-                  :c => up_count + down_count,
-                  :p => klass_value_point[:up]*up_count + klass_value_point[:down]*down_count
+                '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
+              'up_voter_ids' => true,
+              'down_voter_ids' => true,
+              'votes_count' => true,
+              'votes_point' => true,
+              'voteable' => true
             }
           })
         end
-        puts "  #{count} objects migrated." if log
       end
     end
     

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: voteable_mongoid
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
-  - 4
-  version: 0.6.4
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Alex Nguyen