acts_as_votable 0.5.0 → 0.8.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, :vote_by,
+          :up_from, :upvote_from, :upvote_by, :like_from, :liked_from, :vote_from
         ],
 
         :vote_down => [
@@ -27,15 +27,13 @@ module ActsAsVotable
         :down_votes => [
           :false_votes, :downs, :downvotes, :dislikes, :negatives
         ],
-        :unvote => [
-          :unliked_by, :undisliked_by
+        :unvote_for => [
+          :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, :class_name => 'ActsAsVotable::Vote', :as => :votable, :dependent => :destroy do
           def voters
             includes(:voter).map(&:voter)
           end
@@ -84,16 +82,18 @@ module ActsAsVotable
         :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,
           :voter => options[:voter],
           :vote_scope => options[:vote_scope]
         )
+        #Allowing for a vote_weight to be associated with every vote. Could change with every voter object
+        vote.vote_weight = options.fetch(:vote_weight, 1).to_i
       else
         # this voter is potentially changing his vote
-        vote = _votes_.first
+        vote = _votes_.last
       end
 
       last_update = vote.updated_at
@@ -102,7 +102,7 @@ module ActsAsVotable
 
       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
@@ -117,21 +117,52 @@ module ActsAsVotable
 
       return true if _votes_.size == 0
       _votes_.each(&:destroy)
-      update_cached_votes
+      update_cached_votes args[:vote_scope]
       self.vote_registered = false if votes.count == 0
       return true
     end
 
     def vote_up voter, options={}
-      self.vote :voter => voter, :vote => true, :vote_scope => options[:vote_scope]
+      self.vote :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 :voter => voter, :vote => false, :vote_scope => options[:vote_scope], :vote_weight => options[:vote_weight]
+    end
+
+    def unvote_for  voter, options = {}
+      self.unvote :voter => voter, :vote_scope => options[:vote_scope] #Does not need vote_weight since the votes 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_scope
+        "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,7 +185,40 @@ 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
 
@@ -174,25 +238,34 @@ module ActsAsVotable
 
 
     # 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(: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
+      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
+      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 = up_votes(:vote_scope => vote_scope).sum(:vote_weight)
+      downs = down_votes(:vote_scope => vote_scope).sum(:vote_weight)
+      ups - downs
     end
 
     # voters

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
@@ -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,12 +114,10 @@ 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)

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/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

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'sqlite3'
 require 'acts_as_votable'
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
@@ -10,6 +11,7 @@ ActiveRecord::Schema.define(:version => 1) do
 
     t.boolean :vote_flag
     t.string :vote_scope
+    t.integer :vote_weight
 
     t.timestamps
   end
@@ -51,6 +53,13 @@ ActiveRecord::Schema.define(:version => 1) do
     t.integer :cached_votes_score
     t.integer :cached_votes_up
     t.integer :cached_votes_down
+    t.integer :cached_weighted_score
+
+    t.integer :cached_scoped_test_votes_total
+    t.integer :cached_scoped_test_votes_score
+    t.integer :cached_scoped_test_votes_up
+    t.integer :cached_scoped_test_votes_down
+    t.integer :cached_scoped_weighted_score
   end
 
 end

data/spec/votable_spec.rb

@@ -44,6 +44,12 @@ describe ActsAsVotable::Votable do
       @votable.votes.size.should == 1
     end
 
+    it "should have two votes when voted on twice by the same person with duplicate paramenter" do
+      @votable.vote :voter => @voter, :vote => 'yes'
+      @votable.vote :voter => @voter, :vote => 'no', :duplicate => true
+      @votable.votes.size.should == 2
+    end
+
     it "should have one scoped vote when voting under an scope" do
       @votable.vote :voter => @voter, :vote => 'yes', :vote_scope => 'rank'
       @votable.find_votes(:vote_scope => 'rank').size.should == 1
@@ -116,6 +122,12 @@ describe ActsAsVotable::Votable do
       @votable.voted_on_by?(@voter).should be true
     end
 
+    it "should be able to unvote a voter" do
+      @votable.liked_by(@voter)
+      @votable.unliked_by(@voter)
+      @votable.voted_on_by?(@voter).should be false
+    end
+
     it "should unvote a positive vote" do
       @votable.vote :voter => @voter
       @votable.unvote :voter => @voter
@@ -213,6 +225,30 @@ describe ActsAsVotable::Votable do
         @votable_cache.cached_votes_score.should == 0
       end
 
+      it "should update cached weighted score if there is a weighted score column" do
+        @votable_cache.cached_weighted_score = 50
+        @votable_cache.vote :voter => @voter
+        @votable_cache.cached_weighted_score.should == 1
+        @votable_cache.vote :voter => @voter2, :vote => 'false'
+        @votable_cache.cached_weighted_score.should == 0
+        @votable_cache.vote :voter => @voter, :vote => 'false'
+        @votable_cache.cached_weighted_score.should == -2
+      end
+
+      it "should update cached weighted score votes when a vote up is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'true', :vote_weight => 3
+        @votable_cache.cached_weighted_score.should == 3
+        @votable_cache.unvote :voter => @voter
+        @votable_cache.cached_weighted_score.should == 0
+      end
+
+      it "should update cached weighted score votes when a vote down is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_weight => 4
+        @votable_cache.cached_weighted_score.should == -4
+        @votable_cache.unvote :voter => @voter
+        @votable_cache.cached_weighted_score.should == 0
+      end
+
       it "should update cached up votes if there is an up vote column" do
         @votable_cache.cached_votes_up = 50
         @votable_cache.vote :voter => @voter
@@ -256,6 +292,113 @@ describe ActsAsVotable::Votable do
         @votable_cache.count_votes_down.should == 50
       end
 
+      it "should select from cached weighted score if there is a weighted score column" do
+        @votable_cache.vote :voter => @voter, :vote => 'false'
+        @votable_cache.cached_weighted_score = 50
+        @votable_cache.weighted_score.should == 50
+      end
+
+    end
+
+    describe "with scoped cached votes" do
+
+      before(:each) do
+        clean_database
+        @voter = Voter.new(:name => 'i can vote!')
+        @voter.save
+
+        @votable = Votable.new(:name => 'a voting model without a cache')
+        @votable.save
+
+        @votable_cache = VotableCache.new(:name => 'voting model with cache')
+        @votable_cache.save
+      end
+
+      it "should update cached total votes if there is a total column" do
+        @votable_cache.cached_scoped_test_votes_total = 50
+        @votable_cache.vote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_total.should == 1
+      end
+
+      it "should update cached total votes when a vote up is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'true', :vote_scope => "test"
+        @votable_cache.unvote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_total.should == 0
+      end
+
+      it "should update cached total votes when a vote down is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_scope => "test"
+        @votable_cache.unvote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_total.should == 0
+      end
+
+      it "should update cached score votes if there is a score column" do
+        @votable_cache.cached_scoped_test_votes_score = 50
+        @votable_cache.vote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == 1
+        @votable_cache.vote :voter => @voter2, :vote => 'false', :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == 0
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == -2
+      end
+
+      it "should update cached score votes when a vote up is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'true', :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == 1
+        @votable_cache.unvote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == 0
+      end
+
+      it "should update cached score votes when a vote down is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == -1
+        @votable_cache.unvote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_score.should == 0
+      end
+
+      it "should update cached up votes if there is an up vote column" do
+        @votable_cache.cached_scoped_test_votes_up = 50
+        @votable_cache.vote :voter => @voter, :vote_scope => "test"
+        @votable_cache.vote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_up.should == 1
+      end
+
+      it "should update cached down votes if there is a down vote column" do
+        @votable_cache.cached_scoped_test_votes_down = 50
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_down.should == 1
+      end
+
+      it "should update cached up votes when a vote up is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'true', :vote_scope => "test"
+        @votable_cache.unvote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_up.should == 0
+      end
+
+      it "should update cached down votes when a vote down is removed" do
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_scope => "test"
+        @votable_cache.unvote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_down.should == 0
+      end
+
+      it "should select from cached total votes if there a total column" do
+        @votable_cache.vote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_total = 50
+        @votable_cache.count_votes_total(false, "test").should == 50
+      end
+
+      it "should select from cached up votes if there is an up vote column" do
+        @votable_cache.vote :voter => @voter, :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_up = 50
+        @votable_cache.count_votes_up(false, "test").should == 50
+      end
+
+      it "should select from cached down votes if there is a down vote column" do
+        @votable_cache.vote :voter => @voter, :vote => 'false', :vote_scope => "test"
+        @votable_cache.cached_scoped_test_votes_down = 50
+        @votable_cache.count_votes_down(false, "test").should == 50
+      end
+
     end
 
     describe "sti models" do

data/spec/voter_spec.rb

@@ -35,6 +35,7 @@ describe ActsAsVotable::Voter do
     it "should be voted on after a voter has voted" do
       @votable.vote :voter => @voter
       @voter.voted_on?(@votable).should be true
+      @voter.voted_for?(@votable).should be true
     end
 
     it "should not be voted on if a voter has not voted" do
@@ -53,6 +54,7 @@ describe ActsAsVotable::Voter do
 
     it "should be voted as true when a voter has voted true" do
       @votable.vote :voter => @voter
+      @voter.voted_as_when_voted_on(@votable).should be true
       @voter.voted_as_when_voted_for(@votable).should be true
     end
 
@@ -206,6 +208,8 @@ describe ActsAsVotable::Voter do
         @votable2.vote :voter => @voter2
         @voter.find_up_voted_items.should include @votable
         @voter.find_up_voted_items.size.should == 1
+        @voter.find_liked_items.should include @votable
+        @voter.find_liked_items.size.should == 1
       end
 
       it 'returns objects that a user has upvoted for, using scope' do
@@ -242,6 +246,8 @@ describe ActsAsVotable::Voter do
         @votable2.vote_down @voter2
         @voter.find_down_voted_items.should include @votable
         @voter.find_down_voted_items.size.should == 1
+        @voter.find_disliked_items.should include @votable
+        @voter.find_disliked_items.size.should == 1
       end
 
       it 'returns objects that a user has downvoted for, using scope' do