ballot_box 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2011 Aimbulance.
+
+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/README.rdoc

@@ -0,0 +1,96 @@
+= BallotBox
+
+The BallotBox gem enables visitors to vote for and against voteable objects
+
+== Install
+  
+  gem 'ballot_box'
+
+  rails generate ballot_box:install
+  
+== Usage
+
+Use middleware with options:
+
+  # Initialize BallotBox and set its configurations.
+  config.app_middleware.use BallotBox::Manager do |config|
+    config.routes = { "/posts/votes" => "Post" }
+  end
+  
+Set voteable model:
+
+  class Post < ActiveRecord::Base
+    ballot_box :counter_cache => true
+    # ballot_box :counter_cache => :rating, :strategies => [:authenticated]
+  end
+
+View (just send post request to configure route):
+  
+  link_to 'Vote', "/posts/votes?id=#{@post.id}", :remote => true, :method => :post
+
+== Strategies
+
+Strategy - is no more a simple validation at the object vote.
+Authenticated - check :voter attribute is not blank.
+
+  module BallotBox
+    module Strategies
+      class Authenticated < Base
+        validates_presence_of :voter
+      end
+    end
+  end
+  
+Write your own strategies:
+  
+  class MyCustomStrategy < BallotBox::Strategies::Base
+    validate :check_visible, :check_unique_voter
+    
+    protected
+    
+      def check_visible
+        errors.add(:voteable, :invalid) unless voteable.visible?
+      end
+      
+      def check_unique_voter
+        if vote.class.where(["voter_id = ?  AND voter_type = ?", vote.voter_id, vote.voter_type]).exists?
+          errors.add(:voter, :taken)
+        end
+      end
+  end
+
+  class Post < ActiveRecord::Base
+    ballot_box :strategies => [:authenticated, 'MyCustomStrategy']
+  end
+
+== Callbacks
+
+Middleware callbacks:
+  
+  BallotBox::Manager.before_vote do |env, vote|
+    vote.voter = env['warden'].user
+    #vote.errors.add(:voter, :empty)
+  end
+  
+  BallotBox::Manager.after_vote do |env, vote|
+    Rails.logger.info(vote.to_xml)
+  end
+  
+ActiveRecord callbacks:
+
+  class Post < ActiveRecord::Base
+    ballot_box :counter_cache => true
+    
+    before_vote :method_before
+    after_vote :method_after
+    
+    def method_before
+      Rails.logger.info current_vote.to_xml
+      # To terminate register vote, just return false
+      # return false
+    end
+    
+    def method_after
+      
+    end
+  end

data/Rakefile

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require File.join(File.dirname(__FILE__), 'lib', 'ballot_box', 'version')
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the ballot_box plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the ballot_box plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'BallotBox'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "ballot_box"
+    s.version = BallotBox::VERSION.dup
+    s.summary = "The BallotBox gem enables visitors to vote for and against voteable objects"
+    s.description = "The BallotBox gem enables visitors to vote for and against voteable objects"
+    s.email = "galeta.igor@gmail.com"
+    s.homepage = "https://github.com/galetahub/ballot_box"
+    s.authors = ["Igor Galeta", "Pavlo Galeta"]
+    s.files =  FileList["[A-Z]*", "{app,lib}/**/*"] - ["Gemfile"]
+    #s.extra_rdoc_files = FileList["[A-Z]*"]
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/app/models/ballot_box/vote.rb

@@ -0,0 +1,5 @@
+module BallotBox
+  class Vote < ::ActiveRecord::Base
+    include BallotBox::Voting
+  end
+end

data/lib/ballot_box/base.rb

@@ -0,0 +1,74 @@
+module BallotBox
+  module Base
+    def self.included(base)
+      base.extend SingletonMethods
+    end
+    
+    module SingletonMethods
+      #
+      #  ballot_box :counter_cache => true,
+      #             :strategies => [:authenticated]
+      #
+      def ballot_box(options = {})
+        extend ClassMethods
+        include InstanceMethods
+        
+        options = { :strategies => [:authenticated] }.merge(options) 
+        
+        class_attribute :ballot_box_options, :instance_writer => false
+        self.ballot_box_options = options
+        
+        has_many :votes,
+          :class_name => 'BallotBox::Vote', 
+          :as => :voteable,
+          :dependent => :delete_all
+        
+        attr_accessor :current_vote
+        
+        define_ballot_box_callbacks :vote
+      end
+    end
+    
+    module ClassMethods
+    
+      def define_ballot_box_callbacks(*callbacks)
+        define_callbacks *[callbacks, {:terminator => "result == false"}].flatten
+        callbacks.each do |callback|
+          eval <<-end_callbacks
+            def before_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :before, *args, &blk)
+            end
+            def after_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :after, *args, &blk)
+            end
+          end_callbacks
+        end
+      end
+      
+      def ballot_box_cached_column
+        if ballot_box_options[:counter_cache] == true
+          "votes_count"
+        elsif ballot_box_options[:counter_cache]
+          ballot_box_options[:counter_cache]
+        else
+          false
+        end
+      end
+      
+      def ballot_box_strategies
+        @@ballot_box_strategies ||= ballot_box_options[:strategies].map { |st| BallotBox.load_strategy(st) }
+      end
+    end
+    
+    module InstanceMethods
+      
+      def ballot_box_cached_column
+        @ballot_box_cached_column ||= self.class.ballot_box_cached_column
+      end
+      
+      def ballot_box_valid?(vote)
+        self.class.ballot_box_strategies.map { |st| st.new(self, vote) }.map(&:valid?).all?
+      end
+    end
+  end
+end

data/lib/ballot_box/callbacks.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module BallotBox
+  module Callbacks
+    # Hook to _run_callbacks asserting for conditions.
+    def _run_callbacks(kind, *args) #:nodoc:
+      options = args.last # Last callback arg MUST be a Hash
+
+      send("_#{kind}").each do |callback, conditions|
+        invalid = conditions.find do |key, value|
+          value.is_a?(Array) ? !value.include?(options[key]) : (value != options[key])
+        end
+
+        callback.call(*args) unless invalid
+      end
+    end
+    
+    # A callback that runs before create vote
+    # Example:
+    #   BallotBox::Manager.before_vote do |env, opts|
+    #   end
+    #
+    def before_vote(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+      _before_vote.send(method, [block, options])
+    end
+    
+    # Provides access to the callback array for before_vote
+    # :api: private
+    def _before_vote
+      @_before_vote ||= []
+    end
+    
+    # A callback that runs after vote created
+    # Example:
+    #   BallotBox::Manager.after_vote do |env, opts|
+    #   end
+    #
+    def after_vote(options = {}, method = :push, &block)
+      raise BlockNotGiven unless block_given?
+      _after_vote.send(method, [block, options])
+    end
+    
+    # Provides access to the callback array for before_vote
+    # :api: private
+    def _after_vote
+      @_after_vote ||= []
+    end
+  end
+end

data/lib/ballot_box/config.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module BallotBox
+  class Config < Hash
+    # Creates an accessor that simply sets and reads a key in the hash:
+    #
+    # class Config < Hash
+    #   hash_accessor :routes
+    # end
+    #
+    # config = Config.new
+    # config.routes = {'/posts/vote' => 'Post' }
+    # config[:routes] #=> {'/posts/vote' => 'Post' }
+    #
+    def self.hash_accessor(*names) #:nodoc:
+      names.each do |name|
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{name}
+            self[:#{name}]
+          end
+
+          def #{name}=(value)
+            self[:#{name}] = value
+          end
+        METHOD
+      end
+    end
+    
+    hash_accessor :routes
+    
+    def initialize(other={})
+      merge!(other)
+      self[:routes] ||= { "/ballot_box/vote" => 'Class' }
+    end
+  end
+end

data/lib/ballot_box/engine.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require 'rails'
+require 'ballot_box'
+
+module BallotBox
+  class Engine < ::Rails::Engine
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.send :include, BallotBox::Base
+      end
+    end
+  end
+end

data/lib/ballot_box/manager.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module BallotBox
+  class Manager
+    extend BallotBox::Callbacks
+    
+    attr_accessor :config
+    
+    # Initialize the middleware. If a block is given, a BallotBox::Config is yielded so you can properly
+    # configure the BallotBox::Manager.
+    def initialize(app, options={})
+      options.symbolize_keys!
+
+      @app, @config = app, BallotBox::Config.new(options)
+      yield @config if block_given?
+      self
+    end
+    
+    def call(env) # :nodoc:
+      if voting_path?(env['PATH_INFO']) && env["REQUEST_METHOD"] == "POST"
+        create(env)
+      else
+        @app.call(env)
+      end
+    end
+    
+    # :api: private
+    def _run_callbacks(*args) #:nodoc:
+      self.class._run_callbacks(*args)
+    end
+    
+    protected
+      
+      def create(env, body = '', status = 500)
+        request = Rack::Request.new(env)
+        vote = BallotBox::Vote.new(:request => request)
+        vote.voteable_type = @config.routes[ request.path_info ]
+        
+        _run_callbacks(:before_vote, env, vote)
+        
+        body, status = vote.call
+        
+        _run_callbacks(:after_vote, env, vote)
+        
+        [status, {'Content-Type' => 'application/json', 'Content-Length' => body.size.to_s}, body]
+      end
+      
+      def voting_path?(request_path)
+        return false if @config.routes.nil?
+
+        @config.routes.keys.any? do |route|
+          route == request_path
+        end
+      end
+  end
+end

data/lib/ballot_box/strategies/authenticated.rb

@@ -0,0 +1,7 @@
+module BallotBox
+  module Strategies
+    class Authenticated < Base
+      validates_presence_of :voter
+    end
+  end
+end

data/lib/ballot_box/strategies/base.rb

@@ -0,0 +1,26 @@
+require 'active_model/validations'
+
+module BallotBox
+  module Strategies
+    class Base
+      include ActiveModel::Validations
+      
+      attr_accessor :voteable, :vote, :request
+      
+      def initialize(voteable, vote)
+        @voteable = voteable
+        @vote = vote
+        @request = vote.request
+      end
+      
+      def read_attribute_for_validation(key)
+        @vote[key]
+      end
+      
+      # Returns the Errors object that holds all information about attribute error messages.
+      def errors
+        @vote.errors
+      end
+    end
+  end
+end

data/lib/ballot_box/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module BallotBox
+  VERSION = "0.1.0".freeze
+end

data/lib/ballot_box/voting.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+require 'ipaddr'
+require "browser"
+
+module BallotBox
+  module Voting
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :extend,  ClassMethods
+    end
+    
+    module ClassMethods
+      def self.extended(base)
+        base.class_eval do
+          # Associations
+          belongs_to :voteable, :polymorphic => true
+          belongs_to :voter, :polymorphic => true
+          
+          # Validations
+          validates_presence_of :ip_address, :user_agent, :voteable_id, :voteable_type
+          validates_numericality_of :value, :only_integer => true
+          
+          # Callbacks
+          before_save :parse_browser
+          after_save :update_cached_columns
+          after_destroy :update_cached_columns
+
+          attr_accessible :request
+          
+          composed_of :ip,
+            :class_name => 'IPAddr',
+            :mapping => %w(ip_address to_i),
+            :constructor => Proc.new { |ip_address| IPAddr.new(ip_address, Socket::AF_INET) },
+            :converter => Proc.new { |value| value.is_a?(Integer) ? IPAddr.new(value, Socket::AF_INET) : IPAddr.new(value.to_s) }
+          
+          scope :with_voteable, lambda { |record| where(["voteable_id = ? AND voteable_type = ?", record.id, record.class.name]) }
+        end
+      end
+      
+      def chart(mode)
+        result = case mode.to_s.downcase
+          when 'dates' then chart_dates
+          when 'browsers' then chart_browsers
+          when 'platforms' then chart_platforms
+        end
+        
+        [ result ].to_json
+      end
+      
+      protected
+      
+        def chart_dates
+          data = scoped.select("DATE(created_at) AS created_at, SUM(value) AS rating").group("DATE(created_at)").all
+          data.collect { |item| [ item.created_at, item.rating.to_i ] }
+        end
+        
+        def chart_browsers
+          data = scoped.select("browser_name, SUM(value) AS rating").group("browser_name").all
+          data.collect { |item| [ item.browser_name, item.rating.to_i ] }
+        end
+        
+        def chart_platforms
+          data = scoped.select("browser_platform, SUM(value) AS rating").group("browser_platform").all
+          data.collect { |item| [ item.browser_platform, item.rating.to_i ] }
+        end
+    end
+    
+    module InstanceMethods
+    
+      def browser
+        @browser ||= Browser.new(:ua => user_agent, :accept_language => "en-us")
+      end
+      
+      def anonymous?
+        voter.nil?
+      end
+      
+      def as_json(options = nil)
+        options = { 
+          :methods => [:ip], 
+          :only => [:referrer, :value, :browser_version, :browser_name, :user_agent, :browser_platform ] 
+        }.merge(options || {})
+        
+        super
+      end
+      
+      def request
+        @request
+      end
+      
+      def request=(req)
+        self.ip = req.ip
+        self.user_agent = req.user_agent
+        self.referrer = req.referer
+        self.voteable_id = req.params["id"]
+        @request = req
+      end
+      
+      def call
+        if register
+          [self.to_json, 200]
+        else
+          [self.errors.to_json, 422]
+        end
+      end
+      
+      def register
+        if voteable && voteable.ballot_box_valid?(self)
+          voteable.current_vote = self
+          
+          voteable.run_callbacks(:vote) do
+            errors.empty? && save
+          end
+        end
+      end
+      
+      protected
+      
+        def parse_browser
+          self.browser_name = browser.id.to_s
+          self.browser_version = browser.version
+          self.browser_platform = browser.platform.to_s
+        end
+        
+        def update_cached_columns
+          if voteable && voteable.ballot_box_cached_column
+            count = voteable.votes.select("SUM(value)")
+            voteable.class.update_all("#{voteable.ballot_box_cached_column} = (#{count.to_sql})", ["id = ?", voteable.id])
+          end
+        end
+    end
+  end
+end

data/lib/ballot_box.rb

@@ -0,0 +1,26 @@
+module BallotBox
+  autoload :Voting,    'ballot_box/voting'
+  autoload :Manager,   'ballot_box/manager'
+  autoload :Config,    'ballot_box/config'
+  autoload :Callbacks, 'ballot_box/callbacks'
+  autoload :Base,      'ballot_box/base'
+  
+  module Strategies
+    autoload :Base,          'ballot_box/strategies/base'
+    autoload :Authenticated, 'ballot_box/strategies/authenticated'
+  end
+  
+  def self.table_name_prefix
+    'ballot_box_'
+  end
+  
+  def self.load_strategy(name)
+    case name.class.name
+      when "Symbol" then "BallotBox::Strategies::#{name.to_s.classify}".constantize
+      when "String" then name.classify.constantize
+      else name
+    end
+  end
+end
+
+require 'ballot_box/engine' if defined?(Rails)

data/lib/generators/ballot_box/USAGE

@@ -0,0 +1,7 @@
+Usage:
+  rails generate ballot_box:install
+
+Options:
+                 
+Example:
+  rails g ballot_box:install

data/lib/generators/ballot_box/install_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module BallotBox
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      
+      desc "Create ballot_box migration"
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))      
+      
+      # copy migration files
+      def create_migrations
+        migration_template "migrate/create_votes.rb", File.join('db/migrate', "ballot_box_create_votes.rb")
+      end
+      
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          current_time.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+      
+      def self.current_time
+        @current_time ||= Time.now
+        @current_time += 1.minute
+      end
+    end
+  end
+end

data/lib/generators/ballot_box/templates/migrate/create_votes.rb

@@ -0,0 +1,34 @@
+class BallotBoxCreateVotes < ActiveRecord::Migration
+  def self.up
+    create_table :ballot_box_votes do |t|
+      # Voter
+      t.string  :voter_type, :limit => 40
+      t.integer :voter_id
+      
+      # Voteable
+      t.string  :voteable_type, :limit => 40
+      t.integer :voteable_id
+      
+      # User info
+      t.integer :ip_address, :limit => 8
+      t.string  :user_agent
+      t.string  :referrer
+      t.string  :browser_name, :limit => 40
+      t.string  :browser_version, :limit => 15
+      t.string  :browser_platform, :limit => 15
+
+      # Vote value
+      t.integer :value, :default => 1
+		  
+      t.timestamps
+    end
+
+    add_index :ballot_box_votes, [:voter_type, :voter_id]
+    add_index :ballot_box_votes, [:voteable_type, :voteable_id]
+    add_index :ballot_box_votes, :ip_address
+  end
+
+  def self.down
+    drop_table :ballot_box_votes
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: ballot_box
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Igor Galeta
+- Pavlo Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-18 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  name: browser
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: activemodel
+  version_requirements: *id002
+  prerelease: false
+description: The BallotBox gem enables visitors to vote for and against voteable objects
+email: galeta.igor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- app/models/ballot_box/vote.rb
+- lib/ballot_box.rb
+- lib/ballot_box/base.rb
+- lib/ballot_box/callbacks.rb
+- lib/ballot_box/config.rb
+- lib/ballot_box/engine.rb
+- lib/ballot_box/manager.rb
+- lib/ballot_box/strategies/authenticated.rb
+- lib/ballot_box/strategies/base.rb
+- lib/ballot_box/version.rb
+- lib/ballot_box/voting.rb
+- lib/generators/ballot_box/USAGE
+- lib/generators/ballot_box/install_generator.rb
+- lib/generators/ballot_box/templates/migrate/create_votes.rb
+has_rdoc: true
+homepage: https://github.com/galetahub/ballot_box
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: The BallotBox gem enables visitors to vote for and against voteable objects
+test_files: []
+