thumbs_up 0.4.1 → 0.4.3

data/Gemfile

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

data/README.markdown

@@ -87,7 +87,7 @@ You can easily retrieve voteable object collections based on the properties of t
           :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 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
@@ -98,13 +98,12 @@ This will select the Items with between 1 and 10,000 votes, the votes having bee
     :at_least    - Item must have at least X votes
     :at_most     - Item may not have more than X votes
 
-##### Tallying Rank
+##### Tallying Rank ("Plusminus")
 
-Similar to tallying votes, but this will actually return voteable object collections based on a rating 
-system where up votes and down votes get equal rating.  For Instance, a voteable with 3 upvotes and 2 
-downvotes will have a rating in this instance of 1.
+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.
 
-##### Rank_Tally Options:
+##### 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
@@ -117,7 +116,7 @@ downvotes will have a rating in this instance of 1.
 
     positiveVoteCount = voteable.votes_for
     negativeVoteCount = voteable.votes_against
-    plusminus         = voteable.plusminus  # Votes for minus votes against.
+    plusminus         = voteable.plusminus  # Votes for, minus votes against.
 
 	voter.voted_for?(voteable) # True if the voter voted for this object.
 	voter.vote_count(:up | :down | :all) # returns the count of +1, -1, or all votes
@@ -134,7 +133,7 @@ ThumbsUp by default only allows one vote per user. This can be changed by removi
 
     validates_uniqueness_of :voteable_id, :scope => [:voteable_type, :voter_type, :voter_id]
 
-#### In the migration:
+#### In the migration, the unique index:
 
     add_index :votes, ["voter_id", "voter_type", "voteable_id", "voteable_type"], :unique => true, :name => "uniq_one_vote_only"
 

data/Rakefile

@@ -26,21 +26,13 @@ Jeweler::RubygemsDotOrgTasks.new
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
+  test.test_files = Dir.glob("test/**/*_test.rb")
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-require 'rake/rdoctask'
+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*')

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.3

data/lib/acts_as_voteable.rb

@@ -17,57 +17,61 @@ 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. 
+      # 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 
+      # 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
-      #  :conditions  - A piece of SQL conditions to add to the query
-      #  :limit       - The maximum number of voteables to return
-      #  :ascending   - Default false - normal order DESC (i.e. highest rank to lowest)
-      #  :at_least    - Item must have at least X votes
-      #  :at_most     - Item may not have more than X votes
-      def rank_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.where("joined_#{Vote.table_name}.voteable_type = '#{self.name}'")
-	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}.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_votes.Vote_Total >= #{sanitize(options[:at_least])}" : nil),
-		(options[:at_most] ? "joined_votes.Vote_Total <= #{sanitize(options[:at_most])}" : nil)
-		].compact.join(' AND '))
-	
-	t.select("#{self.table_name}.*, joined_#{Vote.table_name}.Vote_Total")
+      #  :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
+      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.where("joined_#{Vote.table_name}.voteable_type = '#{self.name}'")
+            t = t.group("joined_#{Vote.table_name}.voteable_id, joined_#{Vote.table_name}.vote_total, #{column_names_for_tally}")
+            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 = 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")
       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.
@@ -83,22 +87,22 @@ module ThumbsUp
       #  :at_most     - Item may not have more than X votes
       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.
@@ -129,6 +133,14 @@ module ThumbsUp
         Vote.where(:voteable_id => id, :voteable_type => self.class.name, :vote => false).count
       end
 
+      def percent_for
+        (votes_for.to_f * 100 / (self.votes.size + 0.0001)).round
+      end
+
+      def percent_against
+        (votes_against.to_f * 100 / (self.votes.size + 0.0001)).round
+      end
+
       # You'll probably want to use this method to display how 'good' a particular voteable
       # is, and/or sort based on it.
       def plusminus

data/lib/has_karma.rb

@@ -22,7 +22,7 @@ module ThumbsUp #:nodoc:
       ## Not yet implemented. Don't use it!
       # Find the most popular users
       def find_most_karmic
-        find(:all)
+        self.all
       end
 
     end

data/test/test_helper.rb

@@ -0,0 +1,69 @@
+require 'simplecov'
+SimpleCov.start
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => ":memory:"
+)
+
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :votes, :force => true do |t|
+    t.boolean    :vote,     :default => false
+    t.references :voteable, :polymorphic => true, :null => false
+    t.references :voter,    :polymorphic => true
+    t.timestamps
+  end
+
+  add_index :votes, [:voter_id, :voter_type]
+  add_index :votes, [:voteable_id, :voteable_type]
+
+  # Comment out the line below to allow multiple votes per voter on a single entity.  
+  add_index :votes, [:voter_id, :voter_type, :voteable_id, :voteable_type], :unique => true, :name => 'fk_one_vote_per_user_per_entity'
+  
+  create_table :users, :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+  
+  create_table :items, :force => true do |t|
+    t.string :name
+    t.string :description
+  end
+end
+
+require 'thumbs_up'
+
+class Vote < ActiveRecord::Base
+
+  scope :for_voter, lambda { |*args| where(["voter_id = ? AND voter_type = ?", args.first.id, args.first.class.name]) }
+  scope :for_voteable, lambda { |*args| where(["voteable_id = ? AND voteable_type = ?", args.first.id, args.first.class.name]) }
+  scope :recent, lambda { |*args| where(["created_at > ?", (args.first || 2.weeks.ago)]) }
+  scope :descending, order("created_at DESC")
+
+  belongs_to :voteable, :polymorphic => true
+  belongs_to :voter, :polymorphic => true
+
+  attr_accessible :vote, :voter, :voteable
+
+  # Comment out the line below to allow multiple votes per user.
+  validates_uniqueness_of :voteable_id, :scope => [:voteable_type, :voter_type, :voter_id]
+end
+
+class User < ActiveRecord::Base
+  acts_as_voter
+end
+
+class Item < ActiveRecord::Base
+  acts_as_voteable
+end
+
+class Test::Unit::TestCase
+end

data/test/test_thumbs_up.rb

@@ -0,0 +1,229 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_helper')
+
+class TestThumbsUp < Test::Unit::TestCase
+  def setup
+    Vote.delete_all
+    User.delete_all
+    Item.delete_all
+  end
+
+  def test_acts_as_voter_instance_methods
+    user_for = User.create(:name => 'david')
+    user_against = User.create(:name => 'brady')
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+
+    assert_not_nil user_for.vote_for(item)
+    assert_raises(ActiveRecord::RecordInvalid) do
+      user_for.vote_for(item)
+    end
+    assert_equal true, user_for.voted_for?(item)
+    assert_equal false, user_for.voted_against?(item)
+    assert_equal true, user_for.voted_on?(item)
+    assert_equal 1, user_for.vote_count
+    assert_equal 1, user_for.vote_count(:up)
+    assert_equal 0, user_for.vote_count(:down)
+    assert_equal true, user_for.voted_which_way?(item, :up)
+    assert_equal false, user_for.voted_which_way?(item, :down)
+    assert_raises(ArgumentError) do
+      user_for.voted_which_way?(item, :foo)
+    end
+
+    assert_not_nil user_against.vote_against(item)
+    assert_raises(ActiveRecord::RecordInvalid) do
+      user_against.vote_against(item)
+    end
+    assert_equal false, user_against.voted_for?(item)
+    assert_equal true, user_against.voted_against?(item)
+    assert_equal true, user_against.voted_on?(item)
+    assert_equal 1, user_against.vote_count
+    assert_equal 0, user_against.vote_count(:up)
+    assert_equal 1, user_against.vote_count(:down)
+    assert_equal false, user_against.voted_which_way?(item, :up)
+    assert_equal true, user_against.voted_which_way?(item, :down)
+    assert_raises(ArgumentError) do
+      user_against.voted_which_way?(item, :foo)
+    end
+
+    assert_not_nil user_against.vote_exclusively_for(item)
+    assert_equal true, user_against.voted_for?(item)
+
+    assert_not_nil user_for.vote_exclusively_against(item)
+    assert_equal true, user_for.voted_against?(item)
+
+    user_for.clear_votes(item)
+    assert_equal 0, user_for.vote_count
+
+    user_against.clear_votes(item)
+    assert_equal 0, user_against.vote_count
+
+    assert_raises(ArgumentError) do
+      user_for.vote(item, {:direction => :foo})
+    end
+  end
+
+  def test_acts_as_voteable_instance_methods
+    user_for = User.create(:name => 'david')
+    another_user_for = User.create(:name => 'name')
+    user_against = User.create(:name => 'brady')
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+
+    user_for.vote_for(item)
+    another_user_for.vote_for(item)
+
+    assert_equal 2, item.votes_for
+    assert_equal 0, item.votes_against
+    assert_equal 2, item.plusminus
+
+    user_against.vote_against(item)
+
+    assert_equal 1, item.votes_against
+    assert_equal 1, item.plusminus
+
+    assert_equal 3, item.votes_count
+
+    assert_equal 67, item.percent_for
+    assert_equal 33, item.percent_against
+
+    voters_who_voted = item.voters_who_voted
+    assert_equal 3, voters_who_voted.size
+    assert voters_who_voted.include?(user_for)
+    assert voters_who_voted.include?(another_user_for)
+    assert voters_who_voted.include?(user_against)
+
+    non_voting_user = User.create(:name => 'random')
+
+    assert_equal true, item.voted_by?(user_for)
+    assert_equal true, item.voted_by?(another_user_for)
+    assert_equal true, item.voted_by?(user_against)
+    assert_equal false, item.voted_by?(non_voting_user)
+  end
+
+  def test_tally_empty
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+
+    assert_equal 0, Item.tally.length
+  end
+
+  def test_tally_starts_at
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    user = User.create(:name => 'david')
+
+    vote = user.vote_for(item)
+    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
+  end
+
+  def test_tally_end_at
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    user = User.create(:name => 'david')
+
+    vote = user.vote_for(item)
+    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
+  end
+
+  def test_tally_between_start_at_end_at
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    another_item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    user = User.create(:name => 'david')
+
+    vote = user.vote_for(item)
+    vote.created_at = 2.days.ago
+    vote.save
+
+    vote = user.vote_for(another_item)
+    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
+  end
+
+  def test_rank_tally_empty
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+
+    assert_equal 0, Item.rank_tally.length
+  end
+
+  def test_rank_tally_starts_at
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    user = User.create(:name => 'david')
+
+    vote = user.vote_for(item)
+    vote.created_at = 3.days.ago
+    vote.save
+
+    assert_equal 0, Item.rank_tally(:start_at => 2.days.ago).length
+    assert_equal 1, Item.rank_tally(:start_at => 4.days.ago).length
+  end
+
+  def test_rank_tally_end_at
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    user = User.create(:name => 'david')
+
+    vote = user.vote_for(item)
+    vote.created_at = 3.days.from_now
+    vote.save
+
+    assert_equal 0, Item.rank_tally(:end_at => 2.days.from_now).length
+    assert_equal 1, Item.rank_tally(:end_at => 4.days.from_now).length
+  end
+
+  def test_rank_tally_between_start_at_end_at
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    another_item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    user = User.create(:name => 'david')
+
+    vote = user.vote_for(item)
+    vote.created_at = 2.days.ago
+    vote.save
+
+    vote = user.vote_for(another_item)
+    vote.created_at = 3.days.from_now
+    vote.save
+
+    assert_equal 1, Item.rank_tally(:start_at => 3.days.ago, :end_at => 2.days.from_now).length
+    assert_equal 2, Item.rank_tally(:start_at => 3.days.ago, :end_at => 4.days.from_now).length
+  end
+
+  def test_rank_tally_inclusion
+    user = User.create(:name => 'david')
+    item = Item.create(:name => 'XBOX', :description => 'XBOX console')
+    item_not_included = Item.create(:name => 'Playstation', :description => 'Playstation console')
+
+    assert_not_nil user.vote_for(item)
+
+    assert (Item.rank_tally.include? item)
+    assert (not Item.rank_tally.include? item_not_included)
+  end
+
+  def test_rank_tally_default_ordering
+    user = User.create(:name => 'david')
+    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_equal item_for, Item.rank_tally[0]
+    assert_equal item_against, Item.rank_tally[1]
+  end
+
+  def test_rank_tally_ascending_ordering
+    user = User.create(:name => 'david')
+    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_equal item_for, Item.rank_tally(:ascending => true)[1]
+    assert_equal item_against, Item.rank_tally(:ascending => true)[0]
+  end
+end

data/thumbs_up.gemspec

@@ -1,51 +1,63 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{thumbs_up}
-  s.version = IO.read('./VERSION')
+  s.name = "thumbs_up"
+  s.version = "0.4.3"
 
   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 Wnętrzak"]
-  s.date = Date.today.to_s
-  s.description = %q{ThumbsUp provides dead-simple voting capabilities to ActiveRecord models with karma calculation, a la stackoverflow.com.}
-  s.email = %q{brady@ldawn.com}
+  s.authors = ["Brady Bouchard", "Peter Jackson", "Cosmin Radoi", "Bence Nagy", "Rob Maddox", "Wojciech Wn\u{119}trzak"]
+  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 = [
-    ".gitignore",
-     "CHANGELOG.markdown",
-     "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",
-     "thumbs_up.gemspec"
+    "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 = %q{http://github.com/brady8/thumbs_up}
-  s.rdoc_options = ["--charset=UTF-8"]
+  s.homepage = "http://github.com/brady8/thumbs_up"
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Voting for ActiveRecord with multiple vote sources and karma calculation.}
+  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
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     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
 

metadata

@@ -1,35 +1,75 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: thumbs_up
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.4.3
   prerelease: 
-  version: 0.4.1
 platform: ruby
-authors: 
+authors:
 - Brady Bouchard
 - Peter Jackson
 - Cosmin Radoi
 - Bence Nagy
 - Rob Maddox
-- "Wojciech Wn\xC4\x99trzak"
+- Wojciech Wnętrzak
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-04 00:00:00 +10:00
-default_executable: 
-dependencies: []
-
-description: ThumbsUp provides dead-simple voting capabilities to ActiveRecord models with karma calculation, a la stackoverflow.com.
+date: 2011-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70315678927000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70315678927000
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70315678926440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70315678926440
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70315678925900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70315678925900
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70315678925220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70315678925220
+description: ThumbsUp provides dead-simple voting capabilities to ActiveRecord models
+  with karma calculation, a la stackoverflow.com.
 email: brady@ldawn.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.markdown
-files: 
-- .gitignore
+files:
 - CHANGELOG.markdown
+- Gemfile
 - MIT-LICENSE
 - README.markdown
 - Rakefile
@@ -42,34 +82,31 @@ files:
 - lib/has_karma.rb
 - lib/thumbs_up.rb
 - rails/init.rb
+- test/test_helper.rb
+- test/test_thumbs_up.rb
 - thumbs_up.gemspec
-has_rdoc: true
 homepage: http://github.com/brady8/thumbs_up
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Voting for ActiveRecord with multiple vote sources and karma calculation.
 test_files: []
-

data/.gitignore

@@ -1,3 +0,0 @@
-*.gem
-pkg/*
-Gemfile.lock