jy-acts_as_votable 0.3.1

data/lib/acts_as_votable/helpers/words.rb

@@ -0,0 +1,36 @@
+module ActsAsVotable::Helpers
+
+  # this helper provides methods that help find what words are 
+  # up votes and what words are down votes
+  #
+  # It can be called 
+  #
+  # votable_object.votable_words.that_mean_true
+  #
+  module Words
+
+    def votable_words
+      VotableWords
+    end
+
+  end
+
+  class VotableWords
+
+    def self.that_mean_true
+      ['up', 'upvote', 'like', 'liked', 'positive', 'yes', 'good', 'true', 1, true]
+    end
+
+    def self.that_mean_false
+      ['down', 'downvote', 'dislike', 'disliked', 'negative', 'no', 'bad', 'false', 0, false]
+    end
+
+    # check is word is a true or bad vote
+    # if the word is unknown, then it counts it as a true/good
+    # vote.  this exists to allow all voting to be good by default
+    def self.meaning_of word
+      !that_mean_false.include?(word)
+    end
+
+  end
+end

data/lib/acts_as_votable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsVotable
+  VERSION = "0.3.1"
+end

data/lib/acts_as_votable/votable.rb

@@ -0,0 +1,195 @@
+require 'acts_as_votable/helpers/words'
+
+module ActsAsVotable
+  module Votable
+
+    include Helpers::Words
+
+    def self.included base
+ 
+      # allow the user to define these himself 
+      aliases = {
+
+        :vote_up => [
+          :up_by, :upvote_by, :like_by, :liked_by, :vote_by, 
+          :up_from, :upvote_from, :upvote_by, :like_from, :liked_from, :vote_from 
+        ],
+
+        :vote_down => [
+          :down_by, :downvote_by, :dislike_by, :disliked_by,
+          :down_from, :downvote_from, :downvote_by, :dislike_by, :disliked_by
+        ],
+
+        :up_votes => [
+          :true_votes, :ups, :upvotes, :likes, :positives, :for_votes,
+        ],
+
+        :down_votes => [
+          :false_votes, :downs, :downvotes, :dislikes, :negatives
+        ],
+        :unvote => [
+          :unliked_by, :undisliked_by
+        ]
+      }
+
+      base.class_eval do
+
+        belongs_to :votable, :polymorphic => true
+        has_many   :votes, :class_name => "ActsAsVotable::Vote", :as => :votable do
+          def voters
+            includes(:voter).map(&:voter)
+          end
+        end
+
+        aliases.each do |method, links|
+          links.each do |new_method|
+            alias_method(new_method, method)
+          end
+        end
+
+      end
+    end
+
+    attr_accessor :vote_registered
+
+    def vote_registered?
+      return self.vote_registered
+    end
+
+    def default_conditions
+      {
+        :votable_id => self.id,
+        :votable_type => self.class.base_class.name.to_s
+      }
+    end
+
+    # voting
+    def vote args = {}
+
+      options = {
+        :vote => true,
+      }.merge(args)
+
+      self.vote_registered = false
+
+      if options[:voter].nil?
+        return false
+      end
+
+      # find the vote
+      _votes_ = find_votes({
+        :voter_id => options[:voter].id,
+        :voter_type => options[:voter].class.name
+      })
+
+      if _votes_.count == 0
+        # this voter has never voted
+        vote = ActsAsVotable::Vote.new(
+          :votable => self,
+          :voter => options[:voter]
+        )
+      else
+        # this voter is potentially changing his vote
+        vote = _votes_.first
+      end
+
+      last_update = vote.updated_at
+
+      vote.vote_flag = votable_words.meaning_of(options[:vote])
+
+      if vote.save
+        self.vote_registered = true if last_update != vote.updated_at
+        update_cached_votes
+        return true
+      else
+        self.vote_registered = false
+        return false
+      end
+
+    end
+
+    def unvote args = {}
+      return false if args[:voter].nil?
+      _votes_ = find_votes(:voter_id => args[:voter].id, :voter_type => args[:voter].class.name)
+
+      return true if _votes_.size == 0
+      _votes_.each(&:destroy)
+      update_cached_votes
+      self.vote_registered = false if votes.count == 0
+      return true
+    end
+
+    def vote_up voter
+      self.vote :voter => voter, :vote => true
+    end
+
+    def vote_down voter
+      self.vote :voter => voter, :vote => false
+    end
+
+    # caching
+    def update_cached_votes
+
+      updates = {}
+
+      if self.respond_to?(:cached_votes_total=)
+        updates[:cached_votes_total] = count_votes_total(true)
+      end
+
+      if self.respond_to?(:cached_votes_up=)
+        updates[:cached_votes_up] = count_votes_up(true)
+      end
+
+      if self.respond_to?(:cached_votes_down=)
+        updates[:cached_votes_down] = count_votes_down(true)
+      end
+
+      self.update_attributes(updates, :without_protection => true) if updates.size > 0
+
+    end
+
+
+    # results
+    def find_votes extra_conditions = {}
+      votes.where(extra_conditions)
+    end
+
+    def up_votes
+      find_votes(:vote_flag => true)
+    end
+
+    def down_votes
+      find_votes(:vote_flag => false)
+    end
+
+
+    # counting
+    def count_votes_total skip_cache = false
+      if !skip_cache && self.respond_to?(:cached_votes_total)
+        return self.send(:cached_votes_total)
+      end
+      find_votes.count
+    end
+
+    def count_votes_up skip_cache = false
+      if !skip_cache && self.respond_to?(:cached_votes_up)
+        return self.send(:cached_votes_up)
+      end
+      up_votes.count
+    end
+
+    def count_votes_down skip_cache = false
+      if !skip_cache && self.respond_to?(:cached_votes_down)
+        return self.send(:cached_votes_down)
+      end
+      down_votes.count
+    end
+
+    # voters
+    def voted_on_by? voter
+      votes = find_votes :voter_id => voter.id, :voter_type => voter.class.name
+      votes.count > 0
+    end
+
+  end
+end

data/lib/acts_as_votable/vote.rb

@@ -0,0 +1,27 @@
+require 'acts_as_votable/helpers/words'
+
+module ActsAsVotable
+  class Vote < ::ActiveRecord::Base
+
+    include Helpers::Words
+
+    attr_accessible :votable_id, :votable_type,
+      :voter_id, :voter_type,
+      :votable, :voter,
+      :vote_flag
+
+    belongs_to :votable, :polymorphic => true
+    belongs_to :voter, :polymorphic => true
+
+    scope :up, where(:vote_flag => true)
+    scope :down, where(:vote_flag => false)
+    scope :for_type, lambda{ |klass| where(:votable_type => klass) }
+    scope :by_type,  lambda{ |klass| where(:voter_type => klass) }
+
+    validates_presence_of :votable_id
+    validates_presence_of :voter_id
+
+  end
+
+end
+

data/lib/acts_as_votable/voter.rb

@@ -0,0 +1,100 @@
+module ActsAsVotable
+  module Voter
+
+    def self.included(base)
+
+      # allow user to define these
+      aliases = {
+        :vote_up_for   => [:likes, :upvotes, :up_votes],
+        :vote_down_for => [:dislikes, :downvotes, :down_votes],
+        :unvote_for    => [:unlike, :undislike]
+      }
+
+      base.class_eval do
+
+        belongs_to :voter, :polymorphic => true
+        has_many :votes, :class_name => "ActsAsVotable::Vote", :as => :voter do
+          def votables
+            includes(:votable).map(&:votable)
+          end
+        end
+
+        aliases.each do |method, links|
+          links.each do |new_method|
+            alias_method(new_method, method)
+          end
+        end
+
+      end
+
+    end
+
+    # voting
+    def vote args
+      args[:votable].vote args.merge({:voter => self})
+    end
+
+    def vote_up_for model=nil
+      vote :votable => model, :vote => true
+    end
+
+    def vote_down_for model
+      vote :votable => model, :vote => false
+    end
+
+    def unvote_for model
+      model.unvote :voter => self
+    end
+
+    # results
+    def voted_on? votable
+      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name)
+      votes.size > 0
+    end
+    alias :voted_for? :voted_on?
+
+    def voted_up_on? votable
+      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name, :vote_flag => true)
+      votes.size > 0
+    end
+    alias :voted_up_for? :voted_up_on?
+
+    def voted_down_on? votable
+      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name, :vote_flag => false)
+      votes.size > 0
+    end
+    alias :voted_down_for? :voted_down_on?
+
+    def voted_as_when_voting_on votable
+      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name)
+      return nil if votes.size == 0
+      return votes.first.vote_flag
+    end
+    alias :voted_as_when_voted_for :voted_as_when_voting_on
+
+    def find_votes extra_conditions = {}
+      votes.where(extra_conditions)
+    end
+
+    def find_up_votes
+      find_votes :vote_flag => true
+    end
+
+    def find_down_votes
+      find_votes :vote_flag => false
+    end
+
+    def find_votes_for_class klass, extra_conditions = {}
+      find_votes extra_conditions.merge({:votable_type => klass.name})
+    end
+
+    def find_up_votes_for_class klass
+      find_votes_for_class klass, :vote_flag => true
+    end
+
+    def find_down_votes_for_class klass
+      find_votes_for_class klass, :vote_flag => false
+    end
+
+  end
+end

data/lib/generators/acts_as_votable/migration/migration_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators/migration'
+
+module ActsAsVotable
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for votable (votes table)"
+
+    def self.orm
+      Rails::Generators.options[:rails][:orm]
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+    end
+
+    def self.orm_has_migration?
+      [:active_record].include? orm
+    end
+
+    def self.next_migration_number(path)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+
+    def create_migration_file
+      if self.class.orm_has_migration?
+        migration_template 'migration.rb', 'db/migrate/acts_as_votable_migration'
+      end
+    end
+  end
+end

data/lib/generators/acts_as_votable/migration/templates/active_record/migration.rb

@@ -0,0 +1,20 @@
+class ActsAsVotableMigration < ActiveRecord::Migration
+  def self.up
+    create_table :votes do |t|
+
+      t.references :votable, :polymorphic => true
+      t.references :voter, :polymorphic => true
+
+      t.boolean :vote_flag
+
+      t.timestamps
+    end
+
+    add_index :votes, [:votable_id, :votable_type]
+    add_index :votes, [:voter_id, :voter_type]
+  end
+
+  def self.down
+    drop_table :votes
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'acts_as_votable'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :votes do |t|
+    t.references :votable, :polymorphic => true
+    t.references :voter, :polymorphic => true
+
+    t.boolean :vote_flag
+
+    t.timestamps
+  end
+
+  add_index :votes, [:votable_id, :votable_type]
+  add_index :votes, [:voter_id, :voter_type]
+
+  create_table :voters do |t|
+    t.string :name
+  end
+
+  create_table :not_voters do |t|
+    t.string :name
+  end
+
+  create_table :votables do |t|
+    t.string :name
+  end
+
+  create_table :sti_votables do |t|
+    t.string :name
+    t.string :type
+  end
+
+  create_table :sti_not_votables do |t|
+    t.string :name
+    t.string :type
+  end
+
+  create_table :not_votables do |t|
+    t.string :name
+  end
+
+  create_table :votable_caches do |t|
+    t.string :name
+    t.integer :cached_votes_total
+    t.integer :cached_votes_up
+    t.integer :cached_votes_down
+  end
+
+end
+
+
+class Voter < ActiveRecord::Base
+  acts_as_voter
+end
+
+class NotVoter < ActiveRecord::Base
+  
+end
+
+class Votable < ActiveRecord::Base
+  acts_as_votable
+  validates_presence_of :name
+end
+
+class StiVotable < ActiveRecord::Base
+  acts_as_votable
+end
+
+class ChildOfStiVotable < StiVotable
+end
+
+class StiNotVotable < ActiveRecord::Base
+  validates_presence_of :name
+end
+
+class VotableChildOfStiNotVotable < StiNotVotable
+  acts_as_votable
+end
+
+class NotVotable < ActiveRecord::Base
+end
+
+class VotableCache < ActiveRecord::Base
+  acts_as_votable
+  validates_presence_of :name
+end
+
+class ABoringClass
+  def self.hw
+    'hello world'
+  end
+end
+
+
+def clean_database
+  models = [ActsAsVotable::Vote, Voter, NotVoter, Votable, NotVotable, VotableCache]
+  models.each do |model|
+    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+  end
+end