redis_voteable 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.log
+*.rdb

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in redis_voteable.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Chris Brauchli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/redis_voteable.rb

@@ -0,0 +1,63 @@
+require 'active_support/dependencies'
+require 'redis'
+require 'redis_voteable/version'
+require 'redis_voteable/voteable'
+require 'redis_voteable/voter'
+require 'redis_voteable/exceptions'
+
+module RedisVoteable
+  extend ActiveSupport::Concern
+  
+  UP_VOTERS       = "up_voters"
+  DOWN_VOTERS     = "dn_voters"
+  UP_VOTES        = "up_votes"
+  DOWN_VOTES      = "dn_votes"
+  
+  mattr_accessor :redis_voteable_settings
+  @@redis_voteable_settings = {
+        :host => 'localhost',
+        :port => '6379',
+        :db => 0,
+        :key_prefix => "vote:",
+  }
+  mattr_accessor :redis
+  @@redis = Redis.new(@@redis_voteable_settings)
+  
+  def prefixed(sid)
+    "#{@@redis_voteable_settings[:key_prefix]}#{sid}"
+  end
+  
+  def class_key(v)
+    "#{v.class.name}:#{v.id}"
+  end
+
+  module ClassMethods    
+    def voteable?
+      false
+    end
+
+    def voter?
+      false
+    end
+    
+    # Specify a model as voteable.
+    #
+    # Example:
+    # class Question < ActiveRecord::Base
+    #   acts_as_voteable
+    # end
+    def acts_as_voteable 
+      include Voteable
+    end
+
+    # Specify a model as voter.
+    #
+    # Example:
+    # class User < ActiveRecord::Base
+    #   acts_as_voter
+    # end
+    def acts_as_voter
+      include Voter
+    end
+  end
+end

data/lib/redis_voteable/exceptions.rb

@@ -0,0 +1,29 @@
+module RedisVoteable
+  module Exceptions
+    class AlreadyVotedError < StandardError
+      attr_reader :up_vote
+    
+      def initialize(up_vote)
+        vote = if up_vote
+          "up voted"
+        else
+          "down voted"
+        end
+    
+        super "The voteable was already #{vote} by the voter."
+      end
+    end
+    
+    class NotVotedError < StandardError
+      def initialize
+        super "The voteable was not voted by the voter."
+      end
+    end
+
+    class InvalidVoteableError < StandardError
+      def initialize
+        super "Invalid voteable."
+      end
+    end
+  end
+end

data/lib/redis_voteable/version.rb

@@ -0,0 +1,3 @@
+module RedisVoteable
+  VERSION = "0.1.0"
+end

data/lib/redis_voteable/voteable.rb

@@ -0,0 +1,101 @@
+module RedisVoteable
+  module Voteable
+    extend ActiveSupport::Concern
+    
+    included do
+      
+    end
+
+    module ClassMethods
+      def voteable?
+        true
+      end
+      
+      # private
+      # def build_voter(voter)
+      #   tmp = voter.split(':')
+      #   tmp[0, tmp.length - 1].constantize.find(tmp.last)
+      # end
+    end
+    
+    module InstanceMethods
+      def up_votes
+        redis.scard prefixed("#{class_key(self)}:#{UP_VOTERS}")
+      end
+      
+      def down_votes
+        redis.scard prefixed("#{class_key(self)}:#{DOWN_VOTERS}")
+      end
+      
+      def total_votes
+        up_votes + down_votes
+      end
+      
+      # Return the difference between up and and votes.
+      # May be negative if there are more down than up votes.
+      def tally
+        up_votes - down_votes
+      end
+      
+      def up_percentage
+        return (up_votes.to_f * 100 / total_votes) unless votes == 0
+        nil
+      end
+      
+      def down_percentage
+        return (down_votes.to_f * 100 / total_votes) unless votes == 0
+        nil
+      end
+      
+      # Returns an array of objects that are +voter+s that voted on this 
+      # +voteable+. This method can be very slow, as it constructs each
+      # object. Also, it assumes that each object has a +find(id)+ method
+      # defined (e.g., any ActiveRecord object).
+      def voters
+        up_voters | down_voters
+      end
+      
+      def up_voters
+        voters = redis.smembers prefixed("#{class_key(self)}:#{UP_VOTERS}")
+        voters.map do |voter|
+          tmp = voter.split(':')
+          tmp[0, tmp.length-1].join(':').constantize.find(tmp.last)
+        end
+      end
+      
+      def down_voters
+        voters = redis.smembers prefixed("#{class_key(self)}:#{DOWN_VOTERS}")
+        voters.map do |voter|
+          tmp = voter.split(':')
+          tmp[0, tmp.length-1].join(':').constantize.find(tmp.last)
+        end
+      end
+      
+      # Calculates the (lower) bound of the Wilson confidence interval
+      # See: http://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Wilson_score_interval
+      # and: http://www.evanmiller.org/how-not-to-sort-by-average-rating.html
+      def confidence(bound = :lower)
+        #include Math
+        n = up_votes + down_votes
+        if n == 0
+          return 0 if n == 0
+        end
+        z = 1.4395314800662002 # Determines confidence to estimate. 
+                               #    1.0364333771448913 = 70%
+                               #    1.2815515594600038 = 80%
+                               #    1.4395314800662002 = 85%
+                               #    1.644853646608357  = 90%
+                               #    1.9599639715843482 = 95%
+                               #    2.2414027073522136 = 97.5%
+        p_hat = 1.0*up_votes/n
+        left  = p_hat + z*z/(2*n)
+        right = z * Math.sqrt( (p_hat*(1-p_hat) + z*z/(4*n)) / n )
+        under = 1 + z*z/n
+        return (left - right) / under unless bound == :upper
+        return (left + right) / under
+        #return Math.sqrt( p_hat + z * z / ( 2 * n ) - z * ( ( p_hat * ( 1 - p_hat ) + z * z / ( 4 * n ) ) / n ) ) / ( 1 + z * z / n )
+      end
+    end
+    
+  end
+end

data/lib/redis_voteable/voter.rb

@@ -0,0 +1,182 @@
+module RedisVoteable
+  module Voter
+    extend ActiveSupport::Concern
+
+    included do
+      # TODO: add scope
+      # scope :up_voted_for, lambda { |votee| where(:_id => { '$in' =>  votee.up_voter_ids }) }
+      # scope :down_voted_for, lambda { |votee| where(:_id => { '$in' =>  votee.down_voter_ids }) }
+      # scope :voted_for, lambda { |votee| where(:_id => { '$in' =>  votee.voter_ids }) }
+    end
+
+    module ClassMethods
+      def voter?
+        true
+      end
+    end
+    
+    module InstanceMethods
+      def vote(voteable, direction)
+        if direction == :up
+          up_vote(voteable)
+        elsif direction == :down
+          down_vote(voteable)
+        end
+      end
+      
+      def vote!(voteable, direction)
+        if direction == :up
+          up_vote!(voteable)
+        elsif direction == :down
+          down_vote!(voteable)
+        end
+      end
+      
+      # Up vote a +voteable+.
+      # Raises an AlreadyVotedError if the voter already up voted the voteable.
+      # Changes a down vote to an up vote if the the voter already down voted the voteable.
+      def up_vote(voteable)
+        check_voteable(voteable)
+
+        r = redis.multi do
+          redis.srem prefixed("#{class_key(voteable)}:#{DOWN_VOTERS}"), "#{class_key(self)}"
+          redis.srem prefixed("#{class_key(self)}:#{DOWN_VOTES}"), "#{class_key(voteable)}"
+          redis.sadd prefixed("#{class_key(voteable)}:#{UP_VOTERS}"), "#{class_key(self)}"
+          redis.sadd prefixed("#{class_key(self)}:#{UP_VOTES}"), "#{class_key(voteable)}"
+        end
+        raise Exceptions::AlreadyVotedError.new(true) unless r[2] == 1
+        true
+      end
+
+      # Up votes the +voteable+, but doesn't raise an error if the votelable was already up voted.
+      # The vote is simply ignored then.
+      def up_vote!(voteable)
+        begin
+          up_vote(voteable)
+          return true
+        rescue
+          return false
+        end
+      end
+
+      # Down vote a +voteable+.
+      # Raises an AlreadyVotedError if the voter already down voted the voteable.
+      # Changes an up vote to a down vote if the the voter already up voted the voteable.
+      def down_vote(voteable)
+        check_voteable(voteable)
+
+        r = redis.multi do
+          redis.srem prefixed("#{class_key(voteable)}:#{UP_VOTERS}"), "#{class_key(self)}"
+          redis.srem prefixed("#{class_key(self)}:#{UP_VOTES}"), "#{class_key(voteable)}"
+          redis.sadd prefixed("#{class_key(voteable)}:#{DOWN_VOTERS}"), "#{class_key(self)}"
+          redis.sadd prefixed("#{class_key(self)}:#{DOWN_VOTES}"), "#{class_key(voteable)}"
+        end
+        raise Exceptions::AlreadyVotedError.new(false) unless r[2] == 1
+        true
+      end
+
+      # Down votes the +voteable+, but doesn't raise an error if the votelable was already down voted.
+      # The vote is simply ignored then.
+      def down_vote!(voteable)
+        begin
+          down_vote(voteable)
+          return true
+        rescue
+          return false
+        end
+      end
+
+      # Clears an already done vote on a +voteable+.
+      # Raises a NotVotedError if the voter didn't voted for the voteable.
+      def clear_vote(voteable)
+        check_voteable(voteable)
+        
+        r = redis.multi do
+          redis.srem prefixed("#{class_key(voteable)}:#{DOWN_VOTERS}"), "#{class_key(self)}"
+          redis.srem prefixed("#{class_key(self)}:#{DOWN_VOTES}"), "#{class_key(voteable)}"
+          redis.srem prefixed("#{class_key(voteable)}:#{UP_VOTERS}"), "#{class_key(self)}"
+          redis.srem prefixed("#{class_key(self)}:#{UP_VOTES}"), "#{class_key(voteable)}"
+        end
+        raise Exceptions::NotVotedError unless r[0] == 1 || r[2] == 1
+        true
+      end
+
+      # Clears an already done vote on a +voteable+, but doesn't raise an error if
+      # the voteable was not voted. It ignores the unvote then.
+      def clear_vote!(voteable)
+        begin
+          clear_vote(voteable)
+          return true
+        rescue
+          return false
+        end
+      end
+      
+      # Return the total number of votes a voter has cast.
+      def vote_count()
+        up_vote_count + down_vote_count
+      end
+      
+      # Returns the number of upvotes a voter has cast.
+      def up_vote_count()
+        redis.scard prefixed("#{class_key(self)}:#{UP_VOTES}")
+      end
+      
+      # Returns the number of downvotes a voter has cast.
+      def down_vote_count()
+        redis.scard prefixed("#{class_key(self)}:#{DOWN_VOTES}")
+      end
+      
+      # Returns true if the voter voted for the +voteable+.
+      def voted?(voteable)
+        up_voted?(voteable) || down_voted?(voteable)
+      end
+      
+      # Returns :up, :down, or nil.
+      def vote_value?(voteable)
+        return :up   if up_voted?(voteable)
+        return :down if down_voted?(voteable)
+        return nil
+      end
+      
+      # Returns true if the voter up voted the +voteable+.
+      def up_voted?(voteable)
+        redis.sismember prefixed("#{class_key(voteable)}:#{UP_VOTERS}"), "#{class_key(self)}"
+      end
+
+      # Returns true if the voter down voted the +voteable+.
+      def down_voted?(voteable)
+        redis.sismember prefixed("#{class_key(voteable)}:#{DOWN_VOTERS}"), "#{class_key(self)}"
+      end
+      
+      # Returns an array of objects that are +voter+s that voted on this 
+      # +voteable+. This method can be very slow, as it constructs each
+      # object. Also, it assumes that each object has a +find(id)+ method
+      # defined (e.g., any ActiveRecord object).
+      def votings
+        up_votings | down_votings
+      end
+      
+      def up_votings
+        votings = redis.smembers prefixed("#{class_key(self)}:#{UP_VOTES}")
+        votings.map do |voting|
+          tmp = voting.split(':')
+          tmp[0, tmp.length-1].join(':').constantize.find(tmp.last)
+        end
+      end
+      
+      def down_votings
+        votings = redis.smembers prefixed("#{class_key(self)}:#{DOWN_VOTES}")
+        votings.map do |voting|
+          tmp = voting.split(':')
+          tmp[0, tmp.length-1].join(':').constantize.find(tmp.last)
+        end
+      end
+      
+      private
+      def check_voteable(voteable)
+        raise Exceptions::InvalidVoteableError unless voteable.class.respond_to?("voteable?") && voteable.class.voteable?
+      end
+    end
+  end
+end

data/redis_voteable.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis_voteable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis_voteable"
+  s.version     = RedisVoteable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Chris Brauchli"]
+  s.email       = ["cbrauchli@gmail.com"]
+  s.date        = "2011-09-30"
+  s.homepage    = "http://github.com/cbrauchli/redis_voteable"
+  s.summary     = %q{Simple vote management with Redis used as the backend.}
+  s.description = %q{A Redis-backed voting extension for Rails applications. }
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  # Dependencies
+  s.add_dependency "redis", "~> 2.2.0"
+  s.add_dependency "activesupport"
+  
+  # For development only
+  s.add_development_dependency "activerecord", "~> 3.0.0"
+  s.add_development_dependency "sqlite3-ruby", "~> 1.3.0"
+  s.add_development_dependency "bundler", "~> 1.0.0"
+  s.add_development_dependency "rspec", "~> 2.0.0"
+  s.add_development_dependency "database_cleaner", "~> 0.6.7"
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: redis_voteable.sqlite3

data/spec/lib/redis_voteable_spec.rb

@@ -0,0 +1,220 @@
+# spec/lib/redis_voteable_spec.rb
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Redis Voteable" do
+  before(:each) do
+    @voteable = VoteableModel.create(:name => "Votable 1")
+    @voter = VoterModel.create(:name => "Voter 1")
+  end
+
+  it "should create a voteable instance" do
+    @voteable.class.should == VoteableModel
+    @voteable.class.voteable?.should == true
+  end
+
+  it "should create a voter instance" do
+    @voter.class.should == VoterModel
+    @voter.class.voter?.should == true
+  end
+
+  it "should get correct vote summary" do
+    @voter.up_vote(@voteable).should == true
+    @voteable.total_votes.should == 1
+    @voteable.tally.should == 1
+    @voter.down_vote(@voteable).should == true
+    @voteable.total_votes.should == 1
+    @voteable.tally.should == -1
+    @voter.clear_vote(@voteable).should == true
+    @voteable.total_votes.should == 0
+    @voteable.tally.should == 0
+  end
+
+  it "voteable should have up vote votings" do
+    @voteable.up_votes.should == 0
+    @voter.up_vote(@voteable)
+    @voteable.up_votes.should == 1
+    @voteable.voters[0].up_voted?(@voteable).should be_true
+  end
+
+  it "voter should have up vote votings" do
+    @voter.up_vote_count == 0
+    @voter.up_vote(@voteable)
+    @voter.up_vote_count == 1
+    @voter.votings[0].should == @voteable
+  end
+
+  it "voteable should have down vote votings" do
+    @voteable.down_votes.should == 0
+    @voter.down_vote(@voteable)
+    @voteable.down_votes.should == 1
+    @voteable.voters[0].up_voted?(@voteable).should be_false
+    @voteable.voters[0].down_voted?(@voteable).should be_true
+  end
+
+  it "voter should have down vote votings" do
+    @voter.down_vote_count.should == 0
+    @voter.down_vote(@voteable)
+    @voter.down_vote_count.should == 1
+    @voter.votings[0].should == @voteable
+  end
+
+  describe "up vote" do
+    it "should increase up votes of voteable by one" do
+      @voteable.up_votes.should == 0
+      @voter.up_vote(@voteable)
+      @voteable.up_votes.should == 1
+    end
+
+    it "should increase up votes of voter by one" do
+      @voter.up_vote_count.should == 0
+      @voter.up_vote(@voteable)
+      @voter.up_vote_count.should == 1
+    end
+
+    it "should only allow a voter to up vote a voteable once" do
+      @voteable.up_votes.should == 0
+      @voter.up_vote(@voteable)
+      lambda { @voter.up_vote(@voteable) }.should raise_error(RedisVoteable::Exceptions::AlreadyVotedError)
+      @voteable.up_votes.should == 1
+    end
+
+    it "should only allow a voter to up vote a voteable once without raising an error" do
+      @voteable.up_votes.should == 0
+      @voter.up_vote!(@voteable)
+      @voteable.up_votes.should == 1
+      lambda {
+        @voter.up_vote!(@voteable).should == false
+      }.should_not raise_error(RedisVoteable::Exceptions::AlreadyVotedError)
+      @voteable.total_votes.should == 1
+    end
+
+    it "should change a down vote to an up vote" do
+      @voter.down_vote(@voteable)
+      @voteable.up_votes.should == 0
+      @voteable.down_votes.should == 1
+      @voteable.tally.should == -1
+      @voter.up_vote_count.should == 0
+      @voter.down_vote_count.should == 1
+      
+      @voter.up_vote(@voteable)
+      @voteable.up_votes.should == 1
+      @voteable.down_votes.should == 0
+      @voteable.tally.should == 1
+      @voter.up_vote_count.should == 1
+      @voter.down_vote_count.should == 0
+    end
+
+    it "should allow up votes from different voters" do
+      @voter2 = VoterModel.create(:name => "Voter 2")
+      @voter.up_vote(@voteable)
+      @voter2.up_vote(@voteable)
+      @voteable.up_votes.should == 2
+      @voteable.tally.should == 2
+    end
+
+    it "should raise an error for an invalid voteable" do
+      invalid_voteable = InvalidVoteableModel.create
+      lambda { @voter.up_vote(invalid_voteable) }.should raise_error(RedisVoteable::Exceptions::InvalidVoteableError)
+    end
+
+    it "should check if voter up voted voteable" do
+      @voter.up_vote(@voteable)
+      @voter.voted?(@voteable).should be_true
+      @voter.up_voted?(@voteable).should be_true
+      @voter.down_voted?(@voteable).should be_false
+    end
+  end
+
+  describe "down vote" do
+    it "should decrease down votes of voteable by one" do
+      @voteable.down_votes.should == 0
+      @voter.down_vote(@voteable)
+      @voteable.down_votes.should == 1
+    end
+
+    it "should decrease down votes of voter by one" do
+      @voter.down_vote_count.should == 0
+      @voter.down_vote(@voteable)
+      @voter.down_vote_count.should == 1
+    end
+
+    it "should only allow a voter to down vote a voteable once" do
+      @voteable.down_votes.should == 0
+      @voter.down_vote(@voteable)
+      lambda { @voter.down_vote(@voteable) }.should raise_error(RedisVoteable::Exceptions::AlreadyVotedError)
+      @voteable.down_votes.should == 1
+    end
+
+    it "should only allow a voter to down vote a voteable once without raising an error" do
+      @voteable.down_votes.should == 0
+      @voter.down_vote!(@voteable)
+      @voteable.down_votes.should == 1
+      lambda {
+        @voter.down_vote!(@voteable).should == false
+      }.should_not raise_error(RedisVoteable::Exceptions::AlreadyVotedError)
+      @voteable.total_votes.should == 1
+    end
+
+    it "should change an up vote to a down vote" do
+      @voter.up_vote(@voteable)
+      @voteable.up_votes.should == 1
+      @voteable.down_votes.should == 0
+      @voteable.tally.should == 1
+      @voter.up_vote_count.should == 1
+      @voter.down_vote_count.should == 0
+      
+      @voter.down_vote(@voteable)
+      @voteable.up_votes.should == 0
+      @voteable.down_votes.should == 1
+      @voteable.tally.should == -1
+      @voter.up_vote_count.should == 0
+      @voter.down_vote_count.should == 1
+    end
+
+    it "should allow down votes from different voters" do
+      @voter2 = VoterModel.create(:name => "Voter 2")
+      @voter.down_vote(@voteable)
+      @voter2.down_vote(@voteable)
+      @voteable.down_votes.should == 2
+      @voteable.tally.should == -2
+    end
+
+    it "should raise an error for an invalid voteable" do
+      invalid_voteable = InvalidVoteableModel.create
+      lambda { @voter.down_vote(invalid_voteable) }.should raise_error(RedisVoteable::Exceptions::InvalidVoteableError)
+    end
+
+    it "should check if voter down voted voteable" do
+      @voter.down_vote(@voteable)
+      @voter.voted?(@voteable).should be_true
+      @voter.up_voted?(@voteable).should be_false
+      @voter.down_voted?(@voteable).should be_true
+    end
+  end
+
+  describe "clear_vote" do
+    it "should decrease the up votes if up voted before" do
+      @voter.up_vote(@voteable)
+      @voteable.up_votes.should == 1
+      @voter.up_vote_count.should == 1
+      @voter.clear_vote(@voteable)
+      @voteable.up_votes.should == 0
+      @voter.up_vote_count.should == 0
+    end
+
+    it "should raise an error if voter didn't vote for the voteable" do
+      lambda { @voter.clear_vote(@voteable) }.should raise_error(RedisVoteable::Exceptions::NotVotedError)
+    end
+
+    it "should not raise error if voter didn't vote for the voteable and clear_vote! is called" do
+      lambda {
+        @voter.clear_vote!(@voteable).should == false
+      }.should_not raise_error(RedisVoteable::Exceptions::NotVotedError)
+    end
+
+    it "should raise an error for an invalid voteable" do
+      invalid_voteable = InvalidVoteableModel.create
+      lambda { @voter.clear_vote(invalid_voteable) }.should raise_error(RedisVoteable::Exceptions::InvalidVoteableError)
+    end
+  end
+end

data/spec/models.rb

@@ -0,0 +1,13 @@
+# spec/models.rb
+class VoteableModel < ActiveRecord::Base
+  include RedisVoteable
+  acts_as_voteable
+end
+
+class VoterModel < ActiveRecord::Base
+  include RedisVoteable
+  acts_as_voter
+end
+
+class InvalidVoteableModel < ActiveRecord::Base
+end

data/spec/schema.rb

@@ -0,0 +1,14 @@
+# spec/schema.rb
+ActiveRecord::Schema.define :version => 0 do
+  create_table :voteable_models, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :voter_models, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :invalid_voteable_models, :force => true do |t|
+    t.string :name
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+# spec/spec_helper.rb
+require 'rubygems'
+require 'bundler'
+require 'logger'
+require 'rspec'
+require 'active_record'
+require 'database_cleaner'
+ 
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'redis_voteable'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.configurations = YAML::load_file(File.dirname(__FILE__) + '/database.yml')
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'sqlite3')
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+
+  load(File.dirname(__FILE__) + '/schema.rb')
+  load(File.dirname(__FILE__) + '/models.rb')
+end
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  config.filter_run_excluding :exclude => true
+
+  config.mock_with :rspec
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+    #redis = Redis.new
+    #redis.flushdb
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: redis_voteable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Brauchli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70161134771100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70161134771100
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70161134770360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70161134770360
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70161134769280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70161134769280
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: &70161134768500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *70161134768500
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70161134763980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70161134763980
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70161134763320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70161134763320
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: &70161134762000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.7
+  type: :development
+  prerelease: false
+  version_requirements: *70161134762000
+description: ! 'A Redis-backed voting extension for Rails applications. '
+email:
+- cbrauchli@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- Rakefile
+- lib/redis_voteable.rb
+- lib/redis_voteable/exceptions.rb
+- lib/redis_voteable/version.rb
+- lib/redis_voteable/voteable.rb
+- lib/redis_voteable/voter.rb
+- redis_voteable.gemspec
+- redis_voteable.sqlite3
+- spec/database.yml
+- spec/lib/redis_voteable_spec.rb
+- spec/models.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+homepage: http://github.com/cbrauchli/redis_voteable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Simple vote management with Redis used as the backend.
+test_files:
+- spec/database.yml
+- spec/lib/redis_voteable_spec.rb
+- spec/models.rb
+- spec/schema.rb
+- spec/spec_helper.rb