thumbs_up 0.4.6 → 0.5.0

data/Gemfile

@@ -1,13 +1 @@
-source :rubygems
-
-gem 'activerecord'
-
-group :development do
-	gem 'bundler'
-	gem 'jeweler'
-	gem 'simplecov'
-end
-
-group :test do
-	gem 'sqlite3'
-end
+gemspec

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Brady Bouchard (ldawn.com)
+Copyright (c) 2011 Brady Bouchard (thewellinspired.com)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.markdown → README.md}

@@ -1,6 +1,8 @@
 ThumbsUp
 =======
 
+**Note: Version 0.5.x is a breaking change for #plusminus_tally and #tally, with > 50% speedups.**
+
 A ridiculously straightforward and simple package 'o' code to enable voting in your application, a la stackoverflow.com, etc.
 Allows an arbitrary number of entities (users, etc.) to vote on models.
 
@@ -67,50 +69,38 @@ Usage
     voter.vote_exclusively_for(voteable)	# Removes any previous votes by that particular voter, and votes for.
     voter.vote_exclusively_against(voteable)	# Removes any previous votes by that particular voter, and votes against.
 
+    vote.unvote_for(voteable)  # Clears all votes for that user
+
 ### Querying votes
 
 Did the first user vote for the Car with id = 2 already?
 
     u = User.first
-	u.voted_on?(Car.find(2))
+    u.vote_for(Car.find(2))
+    u.voted_on?(Car.find(2)) #=> true
+	
+Did the first user vote for or against the Car with id = 2?
+
+    u = User.first
+    u.vote_for(Car.find(2))
+    u.voted_for?(Car.find(2)) #=> true
+    u.voted_against?(Car.find(2)) #=> false
 
 #### Tallying Votes
 
 You can easily retrieve voteable object collections based on the properties of their votes:
 
-    @items = Item.tally(
-      {  :at_least => 1,
-          :at_most => 10000,
-          :start_at => 2.weeks.ago,
-          :end_at => 1.day.ago,
-          :limit => 10,
-          :order => "items.name DESC"
-      })
-
-This will select the Items with between 1 and 10,000 votes, the votes having been cast within the last two weeks (not including today), then display the 10 last items in an alphabetical list. This tallies all votes, regardless of whether they are +1 (up) or -1 (down).
-
-##### Tally Options:
-    :start_at    - Restrict the votes to those created after a certain time
-    :end_at      - Restrict the votes to those created before a certain time
-    :conditions  - A piece of SQL conditions to add to the query
-    :limit       - The maximum number of voteables to return
-    :order       - A piece of SQL to order by. Eg 'votes.count desc' or 'voteable.created_at desc'
-    :at_least    - Item must have at least X votes
-    :at_most     - Item may not have more than X votes
-
-##### Tallying Rank ("Plusminus")
-
-This is similar to tallying votes, but this will return voteable object collections based on the sum of the differences between up and down votes (ups are +1, downs are -1). For Instance, a voteable with 3 upvotes and 2 
-downvotes will have a plusminus of 1.
-
-##### Plusminus Tally Options:
-    :start_at    - Restrict the votes to those created after a certain time
-    :end_at      - Restrict the votes to those created before a certain time
-    :conditions  - A piece of SQL conditions to add to the query
-    :limit       - The maximum number of voteables to return
-    :ascending   - Boolean Default false.  If specified true, results will be returned in ascending order (from bottom up)
-    :at_least    - Item must have at least X votes
-    :at_most     - Item may not have more than X votes
+    @items = Item.tally.limit(10).where('created_at > ?', 2.days.ago).having('vote_count < 10')
+
+This will select the Items with less than 10 votes, the votes having been cast within the last two days, with a limit of 10 items. *This tallies all votes, regardless of whether they are +1 (up) or -1 (down).* The #tally method returns an ActiveRecord Relation, so you can chain the normal method calls on to it.
+
+#### Tallying Rank ("Plusminus")
+
+**You most likely want to use this over the normal tally**
+
+This is similar to tallying votes, but this will return voteable object collections based on the sum of the differences between up and down votes (ups are +1, downs are -1). For Instance, a voteable with 3 upvotes and 2 downvotes will have a plusminus of 1.
+
+    @items = Item.plusminus_tally.limit(10).where('created_at > ?', 2.days.ago).having('plusminus > 10')
 
 #### Lower level queries
 
@@ -141,7 +131,20 @@ You can also use `--unique-voting false` when running the generator command:
 
     rails generate thumbs_up --unique-voting false
 
+#### Testing ThumbsUp
+
+Testing is a bit more than trivial now as our #tally and #plusminus_tally queries don't function properly under SQLite. To set up for testing:
+
+```
+$ mysql -uroot # You may have set a password locally. Change as needed.
+  > GRANT ALL PRIVILEGES ON 'thumbs_up_test' to 'test'@'localhost' IDENTIFIED BY 'test';
+  > CREATE DATABASE 'thumbs_up_test';
+  > exit;
+
+$ rake # Runs the test suite.
+```
+
 Credits
 =======
 
-Basic scaffold is from Peter Jackson's work on VoteFu / ActsAsVoteable. All code updated for Rails 3, cleaned up for speed and clarity, karma calculation fixed, and (hopefully) zero introduced bugs.
+Basic scaffold is from Peter Jackson's work on VoteFu / ActsAsVoteable. All code updated for Rails 3, cleaned up for speed and clarity, karma calculation fixed, and (hopefully) zero introduced bugs.

data/Rakefile

@@ -1,6 +1,9 @@
 # encoding: UTF-8
 require 'rubygems'
-require 'bundler'
+require 'bundler' unless defined?(Bundler)
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'thumbs_up/version'
 
 begin
   Bundler.setup(:default, :development)
@@ -11,18 +14,6 @@ rescue Bundler::BundlerError => e
 end
 require 'rake'
 
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  gem.name = "thumbs_up"
-  gem.summary = "Voting for ActiveRecord with multiple vote sources and karma calculation."
-  gem.description = "ThumbsUp provides dead-simple voting capabilities to ActiveRecord models with karma calculation, a la stackoverflow.com."
-  gem.email = "brady@ldawn.com"
-  gem.homepage = "http://github.com/brady8/thumbs_up"
-  gem.authors = ["Brady Bouchard", "Peter Jackson", "Cosmin Radoi", "Bence Nagy", "Rob Maddox", "Wojciech Wnętrzak"]
-  # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-end
-Jeweler::RubygemsDotOrgTasks.new
-
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
@@ -30,13 +21,12 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "leaderboard #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+task :build do
+  system "gem build thumbs_up.gemspec"
+end
+ 
+task :release => :build do
+  system "gem push thumbs_up-#{ThumbsUp::VERSION}.gem"
 end
 
 task :default => :test

data/lib/acts_as_voteable.rb

@@ -16,108 +16,35 @@ module ThumbsUp
 
     module SingletonMethods
       
-      # The point of this function is to return rankings based on the difference between up and down votes
-      # assuming equal weighting (i.e. a user with 1 up vote and 1 down vote has a Vote_Total of 0.
-      # First the votes table is joined twiced so that the Vote_Total can be calculated for every ID
-      # Then this table is joined against the specific table passed to this function to allow for
-      # ranking of the items within that table based on the difference between up and down votes.
-            # Options:
-      #  :start_at            - Restrict the votes to those created after a certain time
-      #  :end_at              - Restrict the votes to those created before a certain time
-      #  :ascending           - Default false - normal order DESC (i.e. highest rank to lowest)
-      #  :at_least            - Default 1 - Item must have at least X votes
-      #  :at_most             - Item may not have more than X votes
-      #  :conditions          - (string) Extra conditions, if you'd like.
-      def plusminus_tally(*args)
-        options = args.extract_options!
-
-        tsub0 = Vote
-        tsub0 = tsub0.where("vote = ?", false)
-        tsub0 = tsub0.where("voteable_type = ?", self.name)
-        tsub0 = tsub0.group("voteable_id")
-        tsub0 = tsub0.select("DISTINCT voteable_id, COUNT(vote) as votes_against")
-
-        tsub1 = Vote
-        tsub1 = tsub1.where("vote = ?", true)
-        tsub1 = tsub1.where("voteable_type = ?", self.name)
-        tsub1 = tsub1.group("voteable_id")
-        tsub1 = tsub1.select("DISTINCT voteable_id, COUNT(vote) as votes_for")
-
-        t = self.joins("LEFT OUTER JOIN (SELECT DISTINCT #{Vote.table_name}.*,
-            (COALESCE(vfor.votes_for, 0)-COALESCE(against.votes_against, 0)) AS vote_total
-            FROM (#{Vote.table_name} LEFT JOIN
-            (#{tsub0.to_sql}) AS against ON #{Vote.table_name}.voteable_id = against.voteable_id)
-            LEFT JOIN
-            (#{tsub1.to_sql}) as vfor ON #{Vote.table_name}.voteable_id = vfor.voteable_id)
-            AS joined_#{Vote.table_name} ON #{self.table_name}.#{self.primary_key} =
-            joined_#{Vote.table_name}.voteable_id")
-
-            t = t.group("joined_#{Vote.table_name}.voteable_id, joined_#{Vote.table_name}.vote_total, #{column_names_for_tally}")
-            t = t.limit(options[:limit]) if options[:limit]
-            t = t.where("joined_#{Vote.table_name}.voteable_type = '#{self.name}'")
-            t = t.where("joined_#{Vote.table_name}.created_at >= ?", options[:start_at]) if options[:start_at]
-            t = t.where("joined_#{Vote.table_name}.created_at <= ?", options[:end_at]) if options[:end_at]
-            t = t.where(options[:conditions]) if options[:conditions]
-            t = options[:ascending] ? t.order("joined_#{Vote.table_name}.vote_total") : t.order("joined_#{Vote.table_name}.vote_total DESC")
-
-            t = t.having([
-                  "COUNT(joined_#{Vote.table_name}.voteable_id) > 0",
-                  (options[:at_least] ?
-                    "joined_#{Vote.table_name}.vote_total >= #{sanitize(options[:at_least])}" : nil
-                  ),
-                  (options[:at_most] ?
-                    "joined_#{Vote.table_name}.vote_total <= #{sanitize(options[:at_most])}" : nil
-                  )
-                ].compact.join(' AND '))
-
-            t.select("#{self.table_name}.*, joined_#{Vote.table_name}.vote_total")
+      # Calculate the plusminus for a group of voteables in one database query.
+      # This returns an Arel relation, so you can add conditions as you like chained on to
+      # this method call.
+      # i.e. Posts.tally.where('votes.created_at > ?', 2.days.ago)
+      def plusminus_tally
+        t = self.joins("LEFT OUTER JOIN #{Vote.table_name} ON #{self.table_name}.id = #{Vote.table_name}.voteable_id")
+        t = t.order("plusminus DESC")
+        t = t.group("#{self.table_name}.id")
+        t = t.select("#{self.table_name}.*")
+        t = t.select("SUM(CASE CAST(#{Vote.table_name}.vote AS UNSIGNED) WHEN 1 THEN 1 WHEN 0 THEN -1 ELSE 0 END) AS plusminus")
+        t = t.select("COUNT(#{Vote.table_name}.id) AS vote_count")
       end
-      
+
       # #rank_tally is depreciated.
       alias_method :rank_tally, :plusminus_tally
 
       # Calculate the vote counts for all voteables of my type.
-      # This method returns all voteables with at least one vote.
+      # This method returns all voteables (even without any votes) by default.
       # The vote count for each voteable is available as #vote_count.
-      #
-      # Options:
-      #  :start_at    - Restrict the votes to those created after a certain time
-      #  :end_at      - Restrict the votes to those created before a certain time
-      #  :conditions  - A piece of SQL conditions to add to the query
-      #  :limit       - The maximum number of voteables to return
-      #  :order       - A piece of SQL to order by. Eg 'vote_count DESC' or 'voteable.created_at DESC'
-      #  :at_least    - Item must have at least X votes
-      #  :at_most     - Item may not have more than X votes
+      # This returns an Arel relation, so you can add conditions as you like chained on to
+      # this method call.
+      # i.e. Posts.tally.where('votes.created_at > ?', 2.days.ago)
       def tally(*args)
-        options = args.extract_options!
-
-        # Use the explicit SQL statement throughout for Postgresql compatibility.
-        vote_count = "COUNT(#{Vote.table_name}.voteable_id)"
-
-        t = self.where("#{Vote.table_name}.voteable_type = '#{self.name}'")
-
-        # We join so that you can order by columns on the voteable model.
-        t = t.joins("LEFT OUTER JOIN #{Vote.table_name} ON #{self.table_name}.#{self.primary_key} = #{Vote.table_name}.voteable_id")
-
-        t = t.group("#{Vote.table_name}.voteable_id, #{column_names_for_tally}")
-        t = t.limit(options[:limit]) if options[:limit]
-        t = t.where("#{Vote.table_name}.created_at >= ?", options[:start_at]) if options[:start_at]
-        t = t.where("#{Vote.table_name}.created_at <= ?", options[:end_at]) if options[:end_at]
-        t = t.where(options[:conditions]) if options[:conditions]
-        t = options[:order] ? t.order(options[:order]) : t.order("#{vote_count} DESC")
-
-        # I haven't been able to confirm this bug yet, but Arel (2.0.7) currently blows up
-        # with multiple 'having' clauses. So we hack them all into one for now.
-        # If you have a more elegant solution, a pull request on Github would be greatly appreciated.
-        t = t.having([
-            "#{vote_count} > 0",
-            (options[:at_least] ? "#{vote_count} >= #{sanitize(options[:at_least])}" : nil),
-            (options[:at_most] ? "#{vote_count} <= #{sanitize(options[:at_most])}" : nil)
-            ].compact.join(' AND '))
-        # t = t.having("#{vote_count} > 0")
-        # t = t.having(["#{vote_count} >= ?", options[:at_least]]) if options[:at_least]
-        # t = t.having(["#{vote_count} <= ?", options[:at_most]]) if options[:at_most]
-        t.select("#{self.table_name}.*, COUNT(#{Vote.table_name}.voteable_id) AS vote_count")
+        t = self.joins("LEFT OUTER JOIN #{Vote.table_name} ON #{self.table_name}.id = #{Vote.table_name}.voteable_id")
+        t = t.order("vote_count DESC")
+        t = t.group("#{self.table_name}.id")
+        t = t.select("#{self.table_name}.*")
+        t = t.select("#{Vote.table_name}.*")
+        t = t.select("COUNT(#{Vote.table_name}.id) AS vote_count")
       end
 
       def column_names_for_tally
@@ -129,11 +56,11 @@ module ThumbsUp
     module InstanceMethods
 
       def votes_for
-        Vote.where(:voteable_id => id, :voteable_type => self.class.name, :vote => true).count
+        self.votes.where(:vote => true).count
       end
 
       def votes_against
-        Vote.where(:voteable_id => id, :voteable_type => self.class.name, :vote => false).count
+        self.votes.where(:vote => false).count
       end
 
       def percent_for
@@ -162,7 +89,6 @@ module ThumbsUp
         0 < Vote.where(
               :voteable_id => self.id,
               :voteable_type => self.class.name,
-              :voter_type => voter.class.name,
               :voter_id => voter.id
             ).count
       end

data/lib/acts_as_voter.rb

@@ -77,13 +77,13 @@ module ThumbsUp #:nodoc:
       def vote(voteable, options = {})
         raise ArgumentError, "you must specify :up or :down in order to vote" unless options[:direction] && [:up, :down].include?(options[:direction].to_sym)
         if options[:exclusive]
-          self.clear_votes(voteable)
+          self.unvote_for(voteable)
         end
         direction = (options[:direction].to_sym == :up)
         Vote.create!(:vote => direction, :voteable => voteable, :voter => self)
       end
 
-      def clear_votes(voteable)
+      def unvote_for(voteable)
         Vote.where(
           :voter_id => self.id,
           :voter_type => self.class.name,

data/lib/thumbs_up/version.rb

@@ -0,0 +1,3 @@
+module ThumbsUp
+	VERSION = '0.5.0'
+end

data/test/test_helper.rb

@@ -7,10 +7,18 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'active_record'
 
-ActiveRecord::Base.establish_connection(
-  :adapter => "sqlite3",
-  :database => ":memory:"
-)
+config = {
+  :adapter => 'mysql2',
+  :database => 'thumbs_up_test',
+  :username => 'test',
+  :password => 'test',
+  :socket => '/tmp/mysql.sock'
+}
+
+ActiveRecord::Base.establish_connection(config)
+ActiveRecord::Base.connection.drop_database config[:database] rescue nil
+ActiveRecord::Base.connection.create_database config[:database]
+ActiveRecord::Base.establish_connection(config)
 
 ActiveRecord::Migration.verbose = false
 

data/test/{test_thumbs_up.rb → thumbs_up_test.rb}

@@ -50,10 +50,10 @@ class TestThumbsUp < Test::Unit::TestCase
     assert_not_nil user_for.vote_exclusively_against(item)
     assert_equal true, user_for.voted_against?(item)
 
-    user_for.clear_votes(item)
+    user_for.unvote_for(item)
     assert_equal 0, user_for.vote_count
 
-    user_against.clear_votes(item)
+    user_against.unvote_for(item)
     assert_equal 0, user_against.vote_count
 
     assert_raises(ArgumentError) do
@@ -100,8 +100,7 @@ class TestThumbsUp < Test::Unit::TestCase
 
   def test_tally_empty
     item = Item.create(:name => 'XBOX', :description => 'XBOX console')
-
-    assert_equal 0, Item.tally.length
+    assert_equal 0, Item.tally.having('vote_count > 0').length
   end
 
   def test_tally_starts_at
@@ -112,8 +111,8 @@ class TestThumbsUp < Test::Unit::TestCase
     vote.created_at = 3.days.ago
     vote.save
 
-    assert_equal 0, Item.tally(:start_at => 2.days.ago).length
-    assert_equal 1, Item.tally(:start_at => 4.days.ago).length
+    assert_equal 0, Item.tally.where('created_at > ?', 2.days.ago).length
+    assert_equal 1, Item.tally.where('created_at > ?', 4.days.ago).length
   end
 
   def test_tally_end_at
@@ -124,8 +123,8 @@ class TestThumbsUp < Test::Unit::TestCase
     vote.created_at = 3.days.from_now
     vote.save
 
-    assert_equal 0, Item.tally(:end_at => 2.days.from_now).length
-    assert_equal 1, Item.tally(:end_at => 4.days.from_now).length
+    assert_equal 0, Item.tally.where('created_at < ?', 2.days.from_now).length
+    assert_equal 1, Item.tally.where('created_at < ?', 4.days.from_now).length
   end
 
   def test_tally_between_start_at_end_at
@@ -141,14 +140,18 @@ class TestThumbsUp < Test::Unit::TestCase
     vote.created_at = 3.days.from_now
     vote.save
 
-    assert_equal 1, Item.tally(:start_at => 3.days.ago, :end_at => 2.days.from_now).length
-    assert_equal 2, Item.tally(:start_at => 3.days.ago, :end_at => 4.days.from_now).length
+    assert_equal 1, Item.tally.where('created_at > ?', 3.days.ago).where('created_at < ?', 2.days.from_now).length
+    assert_equal 2, Item.tally.where('created_at > ?', 3.days.ago).where('created_at < ?', 4.days.from_now).length
   end
 
-  def test_plusminus_tally_empty
+  def test_plusminus_tally_not_empty_without_conditions
     item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    assert_equal 1, Item.plusminus_tally.length
+  end
 
-    assert_equal 0, Item.plusminus_tally.length
+  def test_plusminus_tally_empty
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    assert_equal 0, Item.plusminus_tally.having('vote_count > 0').length
   end
 
   def test_plusminus_tally_starts_at
@@ -159,8 +162,8 @@ class TestThumbsUp < Test::Unit::TestCase
     vote.created_at = 3.days.ago
     vote.save
 
-    assert_equal 0, Item.plusminus_tally(:start_at => 2.days.ago).length
-    assert_equal 1, Item.plusminus_tally(:start_at => 4.days.ago).length
+    assert_equal 0, Item.plusminus_tally.where('created_at > ?', 2.days.ago).length
+    assert_equal 1, Item.plusminus_tally.where('created_at > ?', 4.days.ago).length
   end
 
   def test_plusminus_tally_end_at
@@ -171,8 +174,8 @@ class TestThumbsUp < Test::Unit::TestCase
     vote.created_at = 3.days.from_now
     vote.save
 
-    assert_equal 0, Item.plusminus_tally(:end_at => 2.days.from_now).length
-    assert_equal 1, Item.plusminus_tally(:end_at => 4.days.from_now).length
+    assert_equal 0, Item.plusminus_tally.where('created_at < ?', 2.days.from_now).length
+    assert_equal 1, Item.plusminus_tally.where('created_at < ?', 4.days.from_now).length
   end
 
   def test_plusminus_tally_between_start_at_end_at
@@ -188,8 +191,8 @@ class TestThumbsUp < Test::Unit::TestCase
     vote.created_at = 3.days.from_now
     vote.save
 
-    assert_equal 1, Item.plusminus_tally(:start_at => 3.days.ago, :end_at => 2.days.from_now).length
-    assert_equal 2, Item.plusminus_tally(:start_at => 3.days.ago, :end_at => 4.days.from_now).length
+    assert_equal 1, Item.plusminus_tally.where('created_at > ?', 3.days.ago).where('created_at < ?', 2.days.from_now).length
+    assert_equal 2, Item.plusminus_tally.where('created_at > ?', 3.days.ago).where('created_at < ?', 4.days.from_now).length
   end
 
   def test_plusminus_tally_inclusion
@@ -199,20 +202,47 @@ class TestThumbsUp < Test::Unit::TestCase
 
     assert_not_nil user.vote_for(item)
 
-    assert (Item.plusminus_tally.include? item)
-    assert (not Item.plusminus_tally.include? item_not_included)
+    assert (Item.plusminus_tally.having('vote_count > 0').include? item)
+    assert (not Item.plusminus_tally.having('vote_count > 0').include? item_not_included)
+  end
+
+  def test_plusminus_tally_voting_for
+    user1 = User.create(:name => 'david')
+    item = Item.create(:name => 'Playstation', :description => 'Playstation console')
+
+    assert_not_nil user1.vote_for(item)
+
+    assert_equal 1, Item.plusminus_tally[0].vote_count
+    assert_equal 1, Item.plusminus_tally[0].plusminus
+  end
+
+  def test_plusminus_tally_voting_against
+    user1 = User.create(:name => 'david')
+    user2 = User.create(:name => 'john')
+    item = Item.create(:name => 'Playstation', :description => 'Playstation console')
+
+    assert_not_nil user1.vote_against(item)
+    assert_not_nil user2.vote_against(item)
+
+    assert_equal 2, Item.plusminus_tally[0].vote_count
+    assert_equal -2, Item.plusminus_tally[0].plusminus
   end
 
   def test_plusminus_tally_default_ordering
-    user = User.create(:name => 'david')
+    user1 = User.create(:name => 'david')
+    user2 = User.create(:name => 'john')
+    item_twice_for = Item.create(:name => 'XBOX2', :description => 'XBOX2 console')
     item_for = Item.create(:name => 'XBOX', :description => 'XBOX console')
     item_against = Item.create(:name => 'Playstation', :description => 'Playstation console')
 
-    assert_not_nil user.vote_for(item_for)
-    assert_not_nil user.vote_against(item_against)
+    assert_not_nil user1.vote_for(item_for)
+    assert_not_nil user1.vote_for(item_twice_for)
+    assert_not_nil user2.vote_for(item_twice_for)
+    assert_not_nil user1.vote_against(item_against)
 
-    assert_equal item_for, Item.plusminus_tally[0]
-    assert_equal item_against, Item.plusminus_tally[1]
+    assert_equal item_twice_for, Item.plusminus_tally[0]
+    assert_equal item_for, Item.plusminus_tally[1]
+    assert_equal item_against, Item.plusminus_tally[2]
   end
   
   def test_plusminus_tally_limit
@@ -220,7 +250,7 @@ class TestThumbsUp < Test::Unit::TestCase
     items = (0..9).map{ |u| Item.create(:name => "Item #{u}", :description => "Item #{u}") }
     users.each{ |u| items.each { |i| u.vote_for(i) } }
     assert_equal 10, Item.plusminus_tally.length
-    assert_equal 2, Item.plusminus_tally(:limit => 2).length
+    assert_equal 2, Item.plusminus_tally.limit(2).length
   end
 
   def test_plusminus_tally_ascending_ordering
@@ -231,8 +261,8 @@ class TestThumbsUp < Test::Unit::TestCase
     assert_not_nil user.vote_for(item_for)
     assert_not_nil user.vote_against(item_against)
 
-    assert_equal item_for, Item.plusminus_tally(:ascending => true)[1]
-    assert_equal item_against, Item.plusminus_tally(:ascending => true)[0]
+    assert_equal item_for, Item.plusminus_tally.reorder('plusminus ASC')[1]
+    assert_equal item_against, Item.plusminus_tally.reorder('plusminus ASC')[0]
   end
   
   def test_karma

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thumbs_up
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -14,11 +14,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-15 00:00:00.000000000 Z
+date: 2012-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70119174895060 !ruby/object:Gem::Requirement
+  requirement: &70283885105360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -26,10 +26,21 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70119174895060
+  version_requirements: *70283885105360
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70283885104200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70283885104200
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70119174894280 !ruby/object:Gem::Requirement
+  requirement: &70283885103200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -37,10 +48,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70119174894280
+  version_requirements: *70283885103200
 - !ruby/object:Gem::Dependency
-  name: jeweler
-  requirement: &70119174893320 !ruby/object:Gem::Requirement
+  name: mysql2
+  requirement: &70283885118060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -48,10 +59,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70119174893320
+  version_requirements: *70283885118060
 - !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: &70119174892540 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &70283885115780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -59,32 +70,31 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70119174892540
+  version_requirements: *70283885115780
 description: ThumbsUp provides dead-simple voting capabilities to ActiveRecord models
   with karma calculation, a la stackoverflow.com.
-email: brady@ldawn.com
+email:
+- brady@thewellinspired.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.markdown
+extra_rdoc_files: []
 files:
-- CHANGELOG.markdown
-- Gemfile
-- MIT-LICENSE
-- README.markdown
-- Rakefile
-- VERSION
 - lib/acts_as_voteable.rb
 - lib/acts_as_voter.rb
 - lib/generators/thumbs_up/templates/migration.rb
 - lib/generators/thumbs_up/templates/vote.rb
 - lib/generators/thumbs_up/thumbs_up_generator.rb
 - lib/has_karma.rb
+- lib/thumbs_up/version.rb
 - lib/thumbs_up.rb
 - rails/init.rb
 - test/test_helper.rb
-- test/test_thumbs_up.rb
-- thumbs_up.gemspec
+- test/thumbs_up_test.rb
+- CHANGELOG.md
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
 homepage: http://github.com/brady8/thumbs_up
 licenses: []
 post_install_message: 
@@ -97,15 +107,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2487690309587182641
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.10
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.13
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
 summary: Voting for ActiveRecord with multiple vote sources and karma calculation.

data/VERSION

@@ -1 +0,0 @@
-0.4.6

data/thumbs_up.gemspec

@@ -1,63 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "thumbs_up"
-  s.version = File.read('./VERSION').strip
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Brady Bouchard", "Peter Jackson", "Cosmin Radoi", "Bence Nagy", "Rob Maddox", "Wojciech Wnetrzak"]
-  s.date = "2011-09-15"
-  s.description = "ThumbsUp provides dead-simple voting capabilities to ActiveRecord models with karma calculation, a la stackoverflow.com."
-  s.email = "brady@ldawn.com"
-  s.extra_rdoc_files = [
-    "README.markdown"
-  ]
-  s.files = [
-    "CHANGELOG.markdown",
-    "Gemfile",
-    "MIT-LICENSE",
-    "README.markdown",
-    "Rakefile",
-    "VERSION",
-    "lib/acts_as_voteable.rb",
-    "lib/acts_as_voter.rb",
-    "lib/generators/thumbs_up/templates/migration.rb",
-    "lib/generators/thumbs_up/templates/vote.rb",
-    "lib/generators/thumbs_up/thumbs_up_generator.rb",
-    "lib/has_karma.rb",
-    "lib/thumbs_up.rb",
-    "rails/init.rb",
-    "test/test_helper.rb",
-    "test/test_thumbs_up.rb",
-    "thumbs_up.gemspec"
-  ]
-  s.homepage = "http://github.com/brady8/thumbs_up"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
-  s.summary = "Voting for ActiveRecord with multiple vote sources and karma calculation."
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<simplecov>, [">= 0"])
-    else
-      s.add_dependency(%q<activerecord>, [">= 0"])
-      s.add_dependency(%q<bundler>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<simplecov>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, [">= 0"])
-    s.add_dependency(%q<bundler>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<simplecov>, [">= 0"])
-  end
-end
-