acts_as_votable 0.5.0 → 0.9.0

data/lib/acts_as_votable/votable.rb

@@ -6,13 +6,13 @@ module ActsAsVotable
     include Helpers::Words
 
     def self.included base
- 
-      # allow the user to define these himself 
+
+      # allow the user to define these himself
       aliases = {
 
         :vote_up => [
-          :up_by, :upvote_by, :like_by, :liked_by, :vote_by, 
-          :up_from, :upvote_from, :upvote_by, :like_from, :liked_from, :vote_from 
+          :up_by, :upvote_by, :like_by, :liked_by, 
+          :up_from, :upvote_from, :upvote_by, :like_from, :liked_from, :vote_from
         ],
 
         :vote_down => [
@@ -20,22 +20,20 @@ module ActsAsVotable
           :down_from, :downvote_from, :downvote_by, :dislike_by, :disliked_by
         ],
 
-        :up_votes => [
-          :true_votes, :ups, :upvotes, :likes, :positives, :for_votes,
+        :get_up_votes => [
+          :get_true_votes, :get_ups, :get_upvotes, :get_likes, :get_positives, :get_for_votes,
         ],
 
-        :down_votes => [
-          :false_votes, :downs, :downvotes, :dislikes, :negatives
+        :get_down_votes => [
+          :get_false_votes, :get_downs, :get_downvotes, :get_dislikes, :get_negatives
         ],
-        :unvote => [
-          :unliked_by, :undisliked_by
+        :unvote_by => [
+          :unvote_up, :unvote_down, :unliked_by, :undisliked_by
         ]
       }
 
       base.class_eval do
-
-        belongs_to :votable, :polymorphic => true
-        has_many   :votes, :class_name => "ActsAsVotable::Vote", :as => :votable do
+        has_many :votes_for, :class_name => 'ActsAsVotable::Vote', :as => :votable, :dependent => :destroy do
           def voters
             includes(:voter).map(&:voter)
           end
@@ -64,7 +62,7 @@ module ActsAsVotable
     end
 
     # voting
-    def vote args = {}
+    def vote_by args = {}
 
       options = {
         :vote => true,
@@ -78,13 +76,13 @@ module ActsAsVotable
       end
 
       # find the vote
-      _votes_ = find_votes({
+      _votes_ = find_votes_for({
         :voter_id => options[:voter].id,
         :vote_scope => options[:vote_scope],
         :voter_type => options[:voter].class.name
       })
 
-      if _votes_.count == 0
+      if _votes_.count == 0 or options[:duplicate]
         # this voter has never voted
         vote = ActsAsVotable::Vote.new(
           :votable => self,
@@ -93,16 +91,19 @@ module ActsAsVotable
         )
       else
         # this voter is potentially changing his vote
-        vote = _votes_.first
+        vote = _votes_.last
       end
 
       last_update = vote.updated_at
 
       vote.vote_flag = votable_words.meaning_of(options[:vote])
 
+      #Allowing for a vote_weight to be associated with every vote. Could change with every voter object
+      vote.vote_weight = (options[:vote_weight].to_i if options[:vote_weight].present?) || 1
+
       if vote.save
         self.vote_registered = true if last_update != vote.updated_at
-        update_cached_votes
+        update_cached_votes options[:vote_scope]
         return true
       else
         self.vote_registered = false
@@ -113,25 +114,56 @@ module ActsAsVotable
 
     def unvote args = {}
       return false if args[:voter].nil?
-      _votes_ = find_votes(:voter_id => args[:voter].id, :vote_scope => args[:vote_scope], :voter_type => args[:voter].class.name)
+      _votes_ = find_votes_for(:voter_id => args[:voter].id, :vote_scope => args[:vote_scope], :voter_type => args[:voter].class.name)
 
       return true if _votes_.size == 0
       _votes_.each(&:destroy)
-      update_cached_votes
-      self.vote_registered = false if votes.count == 0
+      update_cached_votes args[:vote_scope]
+      self.vote_registered = false if votes_for.count == 0
       return true
     end
 
     def vote_up voter, options={}
-      self.vote :voter => voter, :vote => true, :vote_scope => options[:vote_scope]
+      self.vote_by :voter => voter, :vote => true, :vote_scope => options[:vote_scope], :vote_weight => options[:vote_weight]
     end
 
     def vote_down voter, options={}
-      self.vote :voter => voter, :vote => false, :vote_scope => options[:vote_scope]
+      self.vote_by :voter => voter, :vote => false, :vote_scope => options[:vote_scope], :vote_weight => options[:vote_weight]
+    end
+
+    def unvote_by  voter, options = {}
+      self.unvote :voter => voter, :vote_scope => options[:vote_scope] #Does not need vote_weight since the votes_for are anyway getting destroyed
+    end
+
+    def scope_cache_field field, vote_scope
+      return field if vote_scope.nil?
+
+      case field
+      when :cached_votes_total=
+        "cached_scoped_#{vote_scope}_votes_total="
+      when :cached_votes_total
+        "cached_scoped_#{vote_scope}_votes_total"
+      when :cached_votes_up=
+        "cached_scoped_#{vote_scope}_votes_up="
+      when :cached_votes_up
+        "cached_scoped_#{vote_scope}_votes_up"
+      when :cached_votes_down=
+        "cached_scoped_#{vote_scope}_votes_down="
+      when :cached_votes_down
+        "cached_scoped_#{vote_scope}_votes_down"
+      when :cached_votes_score=
+        "cached_scoped_#{vote_scope}_votes_score="
+      when :cached_votes_score
+        "cached_scoped_#{vote_scope}_votes_score"
+      when :cached_weighted_score
+        "cached_weighted_#{vote_scope}_score"
+      when :cached_weighted_score=
+        "cached_weighted_#{vote_scope}_score="
+      end
     end
 
     # caching
-    def update_cached_votes
+    def update_cached_votes vote_scope = nil
 
       updates = {}
 
@@ -154,50 +186,92 @@ module ActsAsVotable
         )
       end
 
-      self.update_attributes(updates, :without_protection => true) if updates.size > 0
+      if self.respond_to?(:cached_weighted_score=)
+        updates[:cached_weighted_score] = weighted_score(true)
+      end
+
+      if vote_scope
+        if self.respond_to?(scope_cache_field :cached_votes_total=, vote_scope)
+          updates[scope_cache_field :cached_votes_total, vote_scope] = count_votes_total(true, vote_scope)
+        end
+
+        if self.respond_to?(scope_cache_field :cached_votes_up=, vote_scope)
+          updates[scope_cache_field :cached_votes_up, vote_scope] = count_votes_up(true, vote_scope)
+        end
+
+        if self.respond_to?(scope_cache_field :cached_votes_down=, vote_scope)
+          updates[scope_cache_field :cached_votes_down, vote_scope] = count_votes_down(true, vote_scope)
+        end
+
+        if self.respond_to?(scope_cache_field :cached_weighted_score=, vote_scope)
+          updates[scope_cache_field :cached_weighted_score, vote_scope] = weighted_score(true, vote_scope)
+        end
+
+        if self.respond_to?(scope_cache_field :cached_votes_score=, vote_scope)
+          updates[scope_cache_field :cached_votes_score, vote_scope] = (
+            (updates[scope_cache_field :cached_votes_up, vote_scope] || count_votes_up(true, vote_scope)) -
+            (updates[scope_cache_field :cached_votes_down, vote_scope] || count_votes_down(true, vote_scope))
+          )
+        end
+      end
+
+      if (::ActiveRecord::VERSION::MAJOR == 3) && (::ActiveRecord::VERSION::MINOR != 0)
+        self.update_attributes(updates, :without_protection => true) if updates.size > 0
+      else
+        self.update_attributes(updates) if updates.size > 0
+      end
 
     end
 
 
     # results
-    def find_votes extra_conditions = {}
-      votes.where(extra_conditions)
+    def find_votes_for extra_conditions = {}
+      votes_for.where(extra_conditions)
     end
 
-    def up_votes options={}
-      find_votes(:vote_flag => true, :vote_scope => options[:vote_scope])
+    def get_up_votes options={}
+      find_votes_for(:vote_flag => true, :vote_scope => options[:vote_scope])
     end
 
-    def down_votes options={}
-      find_votes(:vote_flag => false, :vote_scope => options[:vote_scope])
+    def get_down_votes options={}
+      find_votes_for(:vote_flag => false, :vote_scope => options[:vote_scope])
     end
 
 
     # counting
-    def count_votes_total skip_cache = false
-      if !skip_cache && self.respond_to?(:cached_votes_total)
-        return self.send(:cached_votes_total)
+    def count_votes_total skip_cache = false, vote_scope = nil
+      if !skip_cache && self.respond_to?(scope_cache_field :cached_votes_total, vote_scope)
+        return self.send(scope_cache_field :cached_votes_total, vote_scope)
+      end
+      find_votes_for(:vote_scope => vote_scope).count
+    end
+
+    def count_votes_up skip_cache = false, vote_scope = nil
+      if !skip_cache && self.respond_to?(scope_cache_field :cached_votes_up, vote_scope)
+        return self.send(scope_cache_field :cached_votes_up, vote_scope)
       end
-      find_votes.count
+      get_up_votes(:vote_scope => vote_scope).count
     end
 
-    def count_votes_up skip_cache = false
-      if !skip_cache && self.respond_to?(:cached_votes_up)
-        return self.send(:cached_votes_up)
+    def count_votes_down skip_cache = false, vote_scope = nil
+      if !skip_cache && self.respond_to?(scope_cache_field :cached_votes_down, vote_scope)
+        return self.send(scope_cache_field :cached_votes_down, vote_scope)
       end
-      up_votes.count
+      get_down_votes(:vote_scope => vote_scope).count
     end
 
-    def count_votes_down skip_cache = false
-      if !skip_cache && self.respond_to?(:cached_votes_down)
-        return self.send(:cached_votes_down)
+    def weighted_score skip_cache = false, vote_scope = nil
+      if !skip_cache && self.respond_to?(scope_cache_field :cached_weighted_score, vote_scope)
+        return self.send(scope_cache_field :cached_weighted_score, vote_scope)
       end
-      down_votes.count
+      ups = get_up_votes(:vote_scope => vote_scope).sum(:vote_weight)
+      downs = get_down_votes(:vote_scope => vote_scope).sum(:vote_weight)
+      ups - downs
     end
 
     # voters
     def voted_on_by? voter
-      votes = find_votes :voter_id => voter.id, :voter_type => voter.class.name
+      votes = find_votes_for :voter_id => voter.id, :voter_type => voter.class.name
       votes.count > 0
     end
 

data/lib/acts_as_votable/vote.rb

@@ -5,16 +5,18 @@ module ActsAsVotable
 
     include Helpers::Words
 
-    attr_accessible :votable_id, :votable_type,
-      :voter_id, :voter_type,
-      :votable, :voter,
-      :vote_flag, :vote_scope
+    if ::ActiveRecord::VERSION::MAJOR < 4
+      attr_accessible :votable_id, :votable_type,
+        :voter_id, :voter_type,
+        :votable, :voter,
+        :vote_flag, :vote_scope
+    end
 
     belongs_to :votable, :polymorphic => true
     belongs_to :voter, :polymorphic => true
 
-    scope :up, where(:vote_flag => true)
-    scope :down, where(:vote_flag => false)
+    scope :up, lambda{ where(:vote_flag => true) }
+    scope :down, lambda{ where(:vote_flag => false) }
     scope :for_type, lambda{ |klass| where(:votable_type => klass) }
     scope :by_type,  lambda{ |klass| where(:voter_type => klass) }
 

data/lib/acts_as_votable/voter.rb

@@ -5,17 +5,20 @@ module ActsAsVotable
 
       # allow user to define these
       aliases = {
-        :vote_up_for   => [:likes, :upvotes, :up_votes],
-        :vote_down_for => [:dislikes, :downvotes, :down_votes],
-        :unvote_for    => [:unlike, :undislike],
+        :vote_up_for    => [:likes, :upvotes, :up_votes],
+        :vote_down_for  => [:dislikes, :downvotes, :down_votes],
+        :unvote_for     => [:unlike, :undislike],
+        :voted_on?      => [:voted_for?],
         :voted_up_on?   => [:voted_up_for?, :liked?],
-        :voted_down_on? => [:voted_down_for?, :disliked?]
+        :voted_down_on? => [:voted_down_for?, :disliked?],
+        :voted_as_when_voting_on => [:voted_as_when_voted_on, :voted_as_when_voting_for, :voted_as_when_voted_for],
+        :find_up_voted_items   => [:find_liked_items],
+        :find_down_voted_items => [:find_disliked_items]
       }
 
       base.class_eval do
 
-        belongs_to :voter, :polymorphic => true
-        has_many :votes, :class_name => "ActsAsVotable::Vote", :as => :voter do
+        has_many :votes, :class_name => 'ActsAsVotable::Vote', :as => :voter, :dependent => :destroy do
           def votables
             includes(:votable).map(&:votable)
           end
@@ -33,7 +36,7 @@ module ActsAsVotable
 
     # voting
     def vote args
-      args[:votable].vote args.merge({:voter => self})
+      args[:votable].vote_by args.merge({:voter => self})
     end
 
     def vote_up_for model=nil, args={}
@@ -44,8 +47,8 @@ module ActsAsVotable
       vote :votable => model, :vote_scope => args[:vote_scope], :vote => false
     end
 
-    def unvote_for model
-      model.unvote :voter => self
+    def unvote_for model, args={}
+      model.unvote :voter => self, :vote_scope => args[:vote_scope]
     end
 
     # results
@@ -66,15 +69,13 @@ module ActsAsVotable
                          :vote_scope => args[:vote_scope], :vote_flag => false)
       votes.size > 0
     end
-    alias :voted_down_for? :voted_down_on?
 
     def voted_as_when_voting_on votable, args={}
-      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.name,
-                         :vote_scope => args[:vote_scope])
-      return nil if votes.size == 0
-      return votes.first.vote_flag
+      vote = find_votes(:votable_id => votable.id, :votable_type => votable.class.name,
+                         :vote_scope => args[:vote_scope]).select(:vote_flag).last
+      return nil unless vote
+      return vote.vote_flag
     end
-    alias :voted_as_when_voted_for :voted_as_when_voting_on
 
     def find_votes extra_conditions = {}
       votes.where(extra_conditions)
@@ -113,23 +114,21 @@ module ActsAsVotable
     def find_up_voted_items extra_conditions = {}
       find_voted_items extra_conditions.merge(:vote_flag => true)
     end
-    alias_method :find_liked_items, :find_up_voted_items
 
     def find_down_voted_items extra_conditions = {}
       find_voted_items extra_conditions.merge(:vote_flag => false)
     end
-    alias_method :find_disliked_items, :find_down_voted_items
 
     def get_voted klass, extra_conditions = {}
-      klass.joins(:votes).merge find_votes(extra_conditions)
+      klass.joins(:votes_for).merge find_votes(extra_conditions)
     end
 
     def get_up_voted klass
-      klass.joins(:votes).merge find_up_votes
+      klass.joins(:votes_for).merge find_up_votes
     end
 
     def get_down_voted klass
-      klass.joins(:votes).merge find_down_votes
+      klass.joins(:votes_for).merge find_down_votes
     end
   end
 end

data/lib/acts_as_votable.rb

@@ -14,3 +14,8 @@ module ActsAsVotable
   end
 
 end
+
+require 'acts_as_votable/extenders/controller'
+ActiveSupport.on_load(:action_controller) do
+  include ActsAsVotable::Extenders::Controller
+end

data/lib/generators/acts_as_votable/migration/migration_generator.rb

@@ -24,8 +24,8 @@ module ActsAsVotable
 
     def create_migration_file
       if self.class.orm_has_migration?
-        migration_template 'migration.rb', 'db/migrate/acts_as_votable_migration'
+        migration_template 'migration.rb', 'db/migrate/acts_as_votable_migration.rb'
       end
     end
   end
-end
+end

data/lib/generators/acts_as_votable/migration/templates/active_record/migration.rb

@@ -7,12 +7,16 @@ class ActsAsVotableMigration < ActiveRecord::Migration
 
       t.boolean :vote_flag
       t.string :vote_scope
+      t.integer :vote_weight
 
       t.timestamps
     end
 
-    add_index :votes, [:votable_id, :votable_type]
-    add_index :votes, [:voter_id, :voter_type]
+    if ActiveRecord::VERSION::MAJOR < 4
+      add_index :votes, [:votable_id, :votable_type]
+      add_index :votes, [:voter_id, :voter_type]
+    end
+
     add_index :votes, [:voter_id, :voter_type, :vote_scope]
     add_index :votes, [:votable_id, :votable_type, :vote_scope]
   end