vote_fu 0.0.11 → 2.0.1

data/examples/voteables_controller.rb

@@ -1,117 +0,0 @@
-# This example controller assumes you are using the User class from restful_authentication
-# and a nested voteable resource. See routes.rb
-
-
-class VoteablesController < ApplicationController
-
-  before_filter :find_user
-  before_filter :login_required, :only => [:new, :edit, :destroy, :create, :update]
-  before_filter :must_own_voteable, :only => [:edit, :destroy, :update]
-
-  # GET /users/:id/voteables
-  # GET /users/:id/voteables.xml
-  def index
-    @voteable = Voteable.descending
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @voteables }
-    end
-  end
-
-  # GET /users/:id/voteables/1
-  # GET /users/:id/voteables/1.xml
-  def show
-    @voteable = Voteable.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml => @voteable }
-    end
-  end
-
-  # GET /users/:id/voteables/new
-  # GET /users/:id/voteables/new.xml
-  def new
-    @voteable = Voteable.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml => @voteable }
-    end
-  end
-
-  # GET /users/:id/voteables/1/edit
-  def edit 
-    @voteable ||= Voteable.find(params[:id])
-  end
-
-  # POST /users/:id/voteables
-  # POST /users/:id/voteables.xml
-  def create
-    @voteable = Voteable.new(params[:voteable])
-    @voteable.user = current_user
-    
-    respond_to do |format|
-      if @voteable.save
-        flash[:notice] = 'Voteable was successfully saved.'
-        format.html { redirect_to([@user, @voteable]) }
-        format.xml  { render :xml => @voteable, :status => :created, :location => @voteable }
-      else
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @voteable.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # PUT /users/:id/voteable/1
-  # PUT /users/:id/voteable/1.xml
-  def update
-    @voteable = Voteable.find(params[:id])
-    
-    respond_to do |format|
-      if @quote.update_attributes(params[:voteable])
-        flash[:notice] = 'Voteable was successfully updated.'
-        format.html { redirect_to([@user, @voteable]) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @voteable.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /users/:id/voteable/1
-  # DELETE /users/:id/voteable/1.xml
-  def destroy
-    @voteable = Voteable.find(params[:id])
-    @voteable.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(user_voteables_url) }
-      format.xml  { head :ok }
-    end
-  end
-  
-  private
-  def find_user 
-    @user = User.find(params[:user_id])
-  end
-    
-  def must_own_voteable
-    @voteable ||= Voteable.find(params[:id])
-    @voteable.user == current_user || ownership_violation
-  end
-  
-  def ownership_violation
-    respond_to do |format|
-      flash[:notice] = 'You cannot edit or delete voteable that you do not own!'
-      format.html do
-        redirect_to user_path(current_user)
-      end
-    end
-  end
-  
-  
-  
-end

data/examples/votes/_voteable_vote.html.erb

@@ -1,23 +0,0 @@
-<% 
-	# You can't vote if it is your quote, 
-	# you are not logged in, 
-	# or you have already voted on this item
-	
-	unless quote.user == current_user ||
-	!logged_in? ||
-	current_user.voted_on?(@voteable)
-%>
-
-	<%= link_to_remote "Up", 
-		:url => user_voteable_votes_path(voteable.user, voteable, :vote => :true, :format => :rjs), 
-		:method => :post
-	%> 
-	/
-	<%= link_to_remote "Down", 
-		:url => user_voteable_votes_path(voteable.user, voteable, :vote => :false, :format => :rjs), 
-		:method => :post
- 	%> 
-
-<% end %>
-
-Votes: <%= voteable.votes_for - voteable.votes_against %>

data/examples/votes/create.rjs

@@ -1 +0,0 @@
-page.replace_html "votes_#{@voteable.id}", :partial => "voteable_vote", :locals => {:voteable => @voteable}

data/examples/votes_controller.rb

@@ -1,110 +0,0 @@
-# An example controller for "votes" that are nested resources under users. See examples/routes.rb
-
-class VotesController < ApplicationController
-
-  # First, figure out our nested scope. User or Voteable? 
-  before_filter :find_votes_for_my_scope, :only => [:index]
-     
-  before_filter :login_required, :only => [:new, :edit, :destroy, :create, :update]
-  before_filter :must_own_vote,  :only => [:edit, :destroy, :update]
-  before_filter :not_allowed,    :only => [:edit, :update, :new]
-
-  # GET /users/:user_id/votes/
-  # GET /users/:user_id/votes.xml
-  # GET /users/:user_id/voteables/:voteable_id/votes/
-  # GET /users/:user_id/voteables/:voteable_id/votes.xml
-  def index
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @votes }
-    end
-  end
-
-  # GET /users/:user_id/votes/1
-  # GET /users/:user_id/votes/1.xml
-  # GET /users/:user_id/voteables/:voteable_id/votes/1
-  # GET /users/:user_id/voteables/:voteable_id/1.xml
-  def show
-    @voteable = Vote.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml => @vote }
-    end
-  end
-
-  # GET /users/:id/votes/new      
-  # GET /users/:id/votes/new.xml  
-  # GET /users/:id/votes/new      
-  # GET /users/:id/votes/new.xml  
-  def new
-    # Not generally used. Most people want to vote via AJAX calls.
-  end
-
-  # GET /users/:id/votes/1/edit
-  def edit
-    # Not generally used. Most people don't want to allow editing of votes.
-  end
-
-  # POST /users/:user_id/voteables/:voteable_id/votes
-  # POST /users/:user_id/voteables/:voteable_id/votes.xml
-  def create
-    @voteable = Voteable.find(params[:quote_id])
-    
-    respond_to do |format|
-      if current_user.vote(@voteable, params[:vote])
-        format.rjs  { render :action => "create", :vote => @vote }
-        format.html { redirect_to([@voteable.user, @voteable]) }
-        format.xml  { render :xml => @voteable, :status => :created, :location => @voteable }
-      else
-        format.rjs  { render :action => "error" }
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @vote.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # PUT /users/:id/votes/1
-  # PUT /users/:id/votes/1.xml
-  def update
-    # Not generally used
-  end
-  
-  # DELETE /users/:id/votes/1
-  # DELETE /users/:id/votes/1.xml
-  def destroy
-    @vote = Vote.find(params[:id])
-    @vote.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(user_votes_url) }
-      format.xml  { head :ok }
-    end
-  end
-
-  private
-  def find_votes_for_my_scope
-    if params[:voteable_id]
-      @votes = Vote.for_voteable(Voteable.find(params[:voteable_id])).descending
-    elsif params[:user_id]
-      @votes = Vote.for_voter(User.find(params[:user_id])).descending         
-    else  
-      @votes = []
-    end
-  end
-
-  def must_own_vote
-    @vote ||= Vote.find(params[:id])
-    @vote.user == current_user || ownership_violation
-  end
-
-  def ownership_violation
-    respond_to do |format|
-      flash[:notice] = 'You cannot edit or delete votes that you do not own!'
-      format.html do
-        redirect_to user_path(current_user)
-      end
-    end
-  end
-
-end

data/generators/vote_fu/templates/migration.rb

@@ -1,21 +0,0 @@
-class VoteFuMigration < ActiveRecord::Migration
-  def self.up
-    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"],       :name => "fk_voters"
-    add_index :votes, ["voteable_id", "voteable_type"], :name => "fk_voteables"
-
-    # If you want to enfore "One Person, One Vote" rules in the database, uncomment the index below
-    # add_index :votes, ["voter_id", "voter_type", "voteable_id", "voteable_type"], :unique => true, :name => "uniq_one_vote_only"
-  end
-
-  def self.down
-    drop_table :votes
-  end
-
-end

data/generators/vote_fu/vote_fu_generator.rb

@@ -1,8 +0,0 @@
-class VoteFuGenerator < Rails::Generator::Base 
-
-  def manifest 
-    record do |m| 
-      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => 'vote_fu_migration'
-    end 
-  end
-end

data/init.rb

@@ -1 +0,0 @@
-require 'vote_fu'

data/lib/acts_as_voteable.rb

@@ -1,114 +0,0 @@
-# ActsAsVoteable
-module Juixe
-  module Acts #:nodoc:
-    module Voteable #:nodoc:
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def acts_as_voteable
-          has_many :votes, :as => :voteable, :dependent => :nullify
-
-          include Juixe::Acts::Voteable::InstanceMethods
-          extend  Juixe::Acts::Voteable::SingletonMethods
-        end        
-      end
-      
-      # This module contains class methods
-      module SingletonMethods
-        
-        # Calculate the vote counts for all voteables of my type.
-        def tally(options = {})
-          find(:all, options_for_tally(options.merge({:order =>"count DESC" })))
-        end
-
-        # 
-        # 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
-        def options_for_tally (options = {})
-            options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit
-
-            scope = scope(:find)
-            start_at = sanitize_sql(["#{Vote.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-            end_at = sanitize_sql(["#{Vote.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
-
-            type_and_context = "#{Vote.table_name}.voteable_type = #{quote_value(base_class.name)}"
-
-            conditions = [
-              type_and_context,
-              options[:conditions],
-              start_at,
-              end_at
-            ]
-
-            conditions = conditions.compact.join(' AND ')
-            conditions = merge_conditions(conditions, scope[:conditions]) if scope
-
-            joins = ["LEFT OUTER JOIN #{Vote.table_name} ON #{table_name}.#{primary_key} = #{Vote.table_name}.voteable_id"]
-            joins << scope[:joins] if scope && scope[:joins]
-            at_least  = sanitize_sql(["COUNT(#{Vote.table_name}.id) >= ?", options.delete(:at_least)]) if options[:at_least]
-            at_most   = sanitize_sql(["COUNT(#{Vote.table_name}.id) <= ?", options.delete(:at_most)]) if options[:at_most]
-            having    = [at_least, at_most].compact.join(' AND ')
-            group_by  = "#{Vote.table_name}.voteable_id HAVING COUNT(#{Vote.table_name}.id) > 0"
-            group_by << " AND #{having}" unless having.blank?
-
-            { :select     => "#{table_name}.*, COUNT(#{Vote.table_name}.id) AS count", 
-              :joins      => joins.join(" "),
-              :conditions => conditions,
-              :group      => group_by
-            }.update(options)          
-        end
-      end
-      
-      # This module contains instance methods
-      module InstanceMethods
-        def votes_for
-          Vote.count(:all, :conditions => [
-            "voteable_id = ? AND voteable_type = ? AND vote = ?",
-            id, self.class.name, true
-          ])
-        end
-        
-        def votes_against
-          Vote.count(:all, :conditions => [
-            "voteable_id = ? AND voteable_type = ? AND vote = ?",
-            id, self.class.name, false
-          ])
-        end
-        
-        # Same as voteable.votes.size
-        def votes_count
-          self.votes.size
-        end
-        
-        def voters_who_voted
-          voters = []
-          self.votes.each { |v|
-            voters << v.voter
-          }
-          voters
-        end
-        
-        def voted_by?(voter)
-          rtn = false
-          if voter
-            self.votes.each { |v|
-              rtn = true if (voter.id == v.voter_id && voter.class.name == v.voter_type)
-            }
-          end
-          rtn
-        end
-        
-        
-      end
-    end
-  end
-end

data/lib/acts_as_voter.rb

@@ -1,75 +0,0 @@
-# ActsAsVoter
-module PeteOnRails
-  module Acts #:nodoc:
-    module Voter #:nodoc:
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def acts_as_voter
-          has_many :votes, :as => :voter, :dependent => :nullify  # If a voting entity is deleted, keep the votes. 
-          include PeteOnRails::Acts::Voter::InstanceMethods
-          extend  PeteOnRails::Acts::Voter::SingletonMethods
-        end
-      end
-      
-      # This module contains class methods
-      module SingletonMethods
-      end
-      
-      # This module contains instance methods
-      module InstanceMethods
-        
-        # Usage user.vote_count(true)  # All +1 votes
-        #       user.vote_count(false) # All -1 votes
-        #       user.vote_count()      # All votes
-        
-        def vote_count(for_or_against = "all")
-          where = (for_or_against == "all") ? 
-            ["voter_id = ? AND voter_type = ?", id, self.class.name ] : 
-            ["voter_id = ? AND voter_type = ? AND vote = ?", id, self.class.name, for_or_against ]
-                        
-          Vote.count(:all, :conditions => where)
-
-        end
-                
-        def voted_for?(voteable)
-           0 < Vote.count(:all, :conditions => [
-                   "voter_id = ? AND voter_type = ? AND vote = ? AND voteable_id = ? AND voteable_type = ?",
-                   self.id, self.class.name, true, voteable.id, voteable.class.name
-                   ])
-         end
-
-         def voted_against?(voteable)
-           0 < Vote.count(:all, :conditions => [
-                   "voter_id = ? AND voter_type = ? AND vote = ? AND voteable_id = ? AND voteable_type = ?",
-                   self.id, self.class.name, false, voteable.id, voteable.class.name
-                   ])
-         end
-
-         def voted_on?(voteable)
-           0 < Vote.count(:all, :conditions => [
-                   "voter_id = ? AND voter_type = ? AND voteable_id = ? AND voteable_type = ?",
-                   self.id, self.class.name, voteable.id, voteable.class.name
-                   ])
-         end
-                
-        def vote_for(voteable)
-          self.vote(voteable, true)
-        end
-        
-        def vote_against(voteable)
-          self.vote(voteable, false)
-        end
-
-        def vote(voteable, vote)
-          vote = Vote.new(:vote => vote, :voteable => voteable, :voter => self)
-          vote.save
-        end
-
-      end
-    end
-  end
-end

data/lib/controllers/votes_controller.rb

@@ -1,96 +0,0 @@
-class VotesController < ApplicationController
-  # First, figure out our nested scope. User or vote?
-#  before_filter :find_my_scope
-  
-#  before_filter :find_user
-    
-#  before_filter :login_required, :only => [:new, :edit, :destroy, :create, :update]
-#  before_filter :must_own_vote,  :only => [:edit, :destroy, :update]
-
-
-  # GET /votes/
-  # GET /votes.xml
-  def index
-    @votes = Vote.descending
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @votes }
-    end
-  end
-
-    # GET /votes/1
-    # GET /votes/1.xml
-    def show
-      @vote = Vote.find(params[:id])
-
-      respond_to do |format|
-        format.html # show.html.erb
-        format.xml  { render :xml => @vote }
-      end
-    end
-
-    # GET /votes/new
-    # GET /votes/new.xml
-    def new
-      @vote = Vote.new
-
-      respond_to do |format|
-        format.html # new.html.erb
-        format.xml  { render :xml => @vote }
-      end
-    end
-
-    # GET /votes/1/edit
-    def edit
-      @vote ||= Vote.find(params[:id])
-    end
-
-    # POST /votes
-    # POST /votes.xml
-    def create
-      @vote = Vote.new(params[:vote])
-      @vote.user = current_user
-
-      respond_to do |format|
-        if @vote.save
-          flash[:notice] = 'Vote was successfully saved.'
-          format.html { redirect_to([@user, @vote]) }
-          format.xml  { render :xml => @vote, :status => :created, :location => @vote }
-        else
-          format.html { render :action => "new" }
-          format.xml  { render :xml => @vote.errors, :status => :unprocessable_entity }
-        end
-      end
-    end
-
-    # PUT /votes/1
-    # PUT /votes/1.xml
-    def update
-      @vote = Vote.find(params[:id])
-
-      respond_to do |format|
-        if @vote.update_attributes(params[:vote])
-          flash[:notice] = 'Vote was successfully updated.'
-          format.html { redirect_to([@user, @vote]) }
-          format.xml  { head :ok }
-        else
-          format.html { render :action => "edit" }
-          format.xml  { render :xml => @vote.errors, :status => :unprocessable_entity }
-        end
-      end
-    end
-
-    # DELETE /votes/1
-    # DELETE /votes/1.xml
-    def destroy
-      @vote = Vote.find(params[:id])
-      @vote.destroy
-
-      respond_to do |format|
-        format.html { redirect_to(user_votes_url) }
-        format.xml  { head :ok }
-      end
-    end
-
-end

data/lib/has_karma.rb

@@ -1,68 +0,0 @@
-# Has Karma
-
-module PeteOnRails
-  module VoteFu #:nodoc:
-    module Karma #:nodoc:
-
-      def self.included(base)
-        base.extend ClassMethods
-        class << base
-          attr_accessor :karmatic_objects
-        end
-      end
-
-      module ClassMethods
-        def has_karma(voteable_type)
-          self.class_eval <<-RUBY
-            def karma_voteable
-              #{voteable_type.to_s.classify}
-            end
-          RUBY
-          include PeteOnRails::VoteFu::Karma::InstanceMethods
-          extend  PeteOnRails::VoteFu::Karma::SingletonMethods
-          if self.karmatic_objects.nil?
-            self.karmatic_objects = [eval(voteable_type.to_s.classify)]
-          else
-            self.karmatic_objects.push(eval(voteable_type.to_s.classify))
-          end
-        end
-      end
-      
-      # This module contains class methods
-      module SingletonMethods
-        
-        ## Not yet implemented. Don't use it!
-        # Find the most popular users
-        def find_most_karmic
-          find(:all)
-        end
-                      
-      end
-      
-      # This module contains instance methods
-      module InstanceMethods
-        def karma(options = {})
-          #FIXME cannot have 2 models imapcting the karma simultaneously
-          # count the total number of votes on all of the voteable objects that are related to this object
-          #2009-01-30 GuillaumeNM The following line is not SQLite3 compatible, because boolean are stored as 'f' or 't', not '1', or '0'
-          #self.karma_voteable.sum(:vote, options_for_karma(options))
-          #self.karma_voteable.find(:all, options_for_karma(options)).length
-          karma_value = 0
-          self.class.karmatic_objects.each do |object|
-            karma_value += object.find(:all, options_for_karma(object, options)).length
-          end
-          return karma_value
-        end
-        
-        def options_for_karma (object, options = {})
-            #GuillaumeNM : 2009-01-30 Adding condition for SQLite3
-            conditions = ["u.id = ? AND vote = ?" , self[:id] , true]
-            joins = ["inner join votes v on #{object.table_name}.id = v.voteable_id", "inner join #{self.class.table_name} u on u.id = #{object.name.tableize}.#{self.class.name.foreign_key}"]
-            { :joins => joins.join(" "), :conditions => conditions }.update(options)          
-        end
-        
-      end
-      
-    end
-  end
-end

data/lib/models/vote.rb

@@ -1,17 +0,0 @@
-class Vote < ActiveRecord::Base
-
-  named_scope :for_voter,    lambda { |*args| {:conditions => ["voter_id = ? AND voter_type = ?", args.first.id, args.first.type.name]} }
-  named_scope :for_voteable, lambda { |*args| {:conditions => ["voteable_id = ? AND voteable_type = ?", args.first.id, args.first.type.name]} }
-  named_scope :recent,       lambda { |*args| {:conditions => ["created_at > ?", (args.first || 2.weeks.ago).to_s(:db)]} }
-  named_scope :descending, :order => "created_at DESC"
-
-  # NOTE: Votes belong to the "voteable" interface, and also to voters
-  belongs_to :voteable, :polymorphic => true
-  belongs_to :voter,    :polymorphic => true
-  
-  attr_accessible :vote, :voter, :voteable
-
-  # Uncomment this to limit users to a single vote on each item. 
-  # validates_uniqueness_of :voteable_id, :scope => [:voteable_type, :voter_type, :voter_id]
-
-end

data/rails/init.rb

@@ -1,10 +0,0 @@
-RAILS_DEFAULT_LOGGER.info "** vote_fu: setting up load paths"
-
-%w{ models controllers helpers }.each do |dir|
-  path = File.join(File.dirname(__FILE__) , 'lib', dir)
-  $LOAD_PATH << path
-  ActiveSupport::Dependencies.load_paths << path
-  ActiveSupport::Dependencies.load_once_paths.delete(path)
-end
-
-require 'vote_fu'

data/test/vote_fu_test.rb

@@ -1,8 +0,0 @@
-require 'test/unit'
-
-class VoteFuTest < Test::Unit::TestCase
-  # Replace this with your real tests.
-  def test_this_plugin
-    flunk
-  end
-end