formal-vote 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61ef60f50f00c23f217782d03bd3c03938dc0fe6
+  data.tar.gz: 2f1570afc9716aaf85546963b025a2332708caf0
+SHA512:
+  metadata.gz: 3e9b3719432da9d66f6a2e464e46db2dcea655b80ad4c9bf96472e5df9268293107eb3ffe910efe8f50de9019513575238ef1b663e7842887bfab4a7d36af5bd
+  data.tar.gz: ff47bda3fa8ce8d1770263ab6133baf5d24104429e0e944aecb9544d228c26764a10e76174eb494c87428fbccf69d13f24330d9ea10a52eed3bd7d6c7a1363fd

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ben Sharman
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# FormalVote
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'formal-vote'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install formal-vote
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/formal-vote.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'formal-vote/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "formal-vote"
+  spec.version       = FormalVote::VERSION
+  spec.authors       = ["Ben Sharman"]
+  spec.email         = ["benwebdev@gmail.com"]
+  spec.description   = "A voting library providing methods for a user to vote for, against, or abstain on a model"
+  spec.summary       = "Formal voting library"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/acts_as_votable.rb

@@ -0,0 +1,135 @@
+module FormalVote
+  module ActsAsVoteable #:nodoc:
+
+    def self.included(base)
+      base.extend FormalVote::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_voteable
+        has_many FormalVote.configuration[:voteable_relationship_name],
+                 :as => :voteable,
+                 :dependent => :destroy,
+                 :class_name => 'Vote'
+
+        include FormalVote::ActsAsVoteable::InstanceMethods
+        extend  FormalVote::ActsAsVoteable::SingletonMethods
+      end
+    end
+
+    module SingletonMethods
+
+      # Calculate the plusminus for a group of voteables in one database query.
+      # This returns an Arel relation, so you can add conditions as you like chained on to
+      # this method call.
+      # i.e. Posts.tally.where('votes.created_at > ?', 2.days.ago)
+      # You can also have the upvotes and downvotes returned separately in the same query:
+      # Post.plusminus_tally(:separate_updown => true)
+      def plusminus_tally(params = {})
+        t = self.joins("LEFT OUTER JOIN #{Vote.table_name} ON #{self.table_name}.id = #{Vote.table_name}.voteable_id AND #{Vote.table_name}.voteable_type = '#{self.name}'")
+        t = t.order("plusminus_tally DESC")
+        t = t.group(column_names_for_tally)
+        t = t.select("#{self.table_name}.*")
+        t = t.select("SUM(CASE #{Vote.table_name}.vote WHEN #{quoted_true} THEN 1 WHEN #{quoted_false} THEN -1 ELSE 0 END) AS plusminus_tally")
+        if params[:separate_updown]
+          t = t.select("SUM(CASE #{Vote.table_name}.vote WHEN #{quoted_true} THEN 1 WHEN #{quoted_false} THEN 0 ELSE 0 END) AS up")
+          t = t.select("SUM(CASE #{Vote.table_name}.vote WHEN #{quoted_true} THEN 0 WHEN #{quoted_false} THEN 1 ELSE 0 END) AS down")
+        end
+        t = t.select("COUNT(#{Vote.table_name}.id) AS vote_count")
+      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 (even without any votes) by default.
+      # The vote count for each voteable is available as #vote_count.
+      # This returns an Arel relation, so you can add conditions as you like chained on to
+      # this method call.
+      # i.e. Posts.tally.where('votes.created_at > ?', 2.days.ago)
+      def tally(*args)
+        t = self.joins("LEFT OUTER JOIN #{Vote.table_name} ON #{self.table_name}.id = #{Vote.table_name}.voteable_id")
+        t = t.order("vote_count DESC")
+        t = t.group(column_names_for_tally)
+        t = t.select("#{self.table_name}.*")
+        t = t.select("COUNT(#{Vote.table_name}.id) AS vote_count")
+      end
+
+      def column_names_for_tally
+        column_names.map { |column| "#{self.table_name}.#{column}" }.join(', ')
+      end
+
+    end
+
+    module InstanceMethods
+
+      # wraps the dynamic, configured, relationship name
+      def _votes_on
+        self.send(FormalVote.configuration[:voteable_relationship_name])
+      end
+
+      def votes_for
+        self._votes_on.where(:vote => true).count
+      end
+
+      def votes_against
+        self._votes_on.where(:vote => false).count
+      end
+
+      def percent_for
+        (votes_for.to_f * 100 / (self._votes_on.size + 0.0001)).round
+      end
+
+      def percent_against
+        (votes_against.to_f * 100 / (self._votes_on.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.
+      # If you're using this for a lot of voteables, then you'd best use the #plusminus_tally
+      # method above.
+      def plusminus
+        respond_to?(:plusminus_tally) ? plusminus_tally : (votes_for - votes_against)
+      end
+
+      # The lower bound of a Wilson Score with a default confidence interval of 95%. Gives a more accurate representation of average rating (plusminus) based on the number of positive ratings and total ratings.
+      # http://evanmiller.org/how-not-to-sort-by-average-rating.html
+      def ci_plusminus(confidence = 0.95)
+        require 'statistics2'
+        n = self._votes_on.size
+        if n == 0
+          return 0
+        end
+        z = Statistics2.pnormaldist(1 - (1 - confidence) / 2)
+        phat = 1.0 * votes_for / n
+        (phat + z * z / (2 * n) - z * Math.sqrt((phat * (1 - phat) + z * z / (4 * n)) / n)) / (1 + z * z / n)
+      end
+
+      def votes_count
+        _votes_on.size
+      end
+
+      def voters_who_voted
+        _votes_on.map(&:voter).uniq
+      end
+
+      def voters_who_voted_for
+          _votes_on.where(:vote => true).map(&:voter).uniq
+      end
+
+      def voters_who_voted_against
+          _votes_on.where(:vote => false).map(&:voter).uniq
+      end
+
+      def voted_by?(voter)
+        0 < Vote.where(
+              :voteable_id => self.id,
+              :voteable_type => self.class.base_class.name,
+              :voter_id => voter.id
+            ).count
+      end
+
+    end
+  end
+end

data/lib/acts_as_voter.rb

@@ -0,0 +1,137 @@
+module FormalVote #:nodoc:
+  module ActsAsVoter #:nodoc:
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_voter
+
+        # If a voting entity is deleted, keep the votes.
+        # If you want to nullify (and keep the votes), you'll need to remove
+        # the unique constraint on the [ voter, voteable ] index in the database.
+        # has_many :votes, :as => :voter, :dependent => :nullify
+        # Destroy voter's votes when the voter is deleted.
+        has_many FormalVote.configuration[:voter_relationship_name],
+                 :as => :voter,
+                 :dependent => :destroy,
+                 :class_name => 'Vote'
+
+        include FormalVote::ActsAsVoter::InstanceMethods
+        extend  FormalVote::ActsAsVoter::SingletonMethods
+      end
+    end
+
+    # This module contains class methods
+    module SingletonMethods
+    end
+
+    # This module contains instance methods
+    module InstanceMethods
+
+      # wraps the dynamic, configured, relationship name
+      def _votes_by
+        self.send(FormalVote.configuration[:voter_relationship_name])
+      end
+
+      # Usage user.vote_count(:up)  # All +1 votes
+      #       user.vote_count(:down) # All -1 votes
+      #       user.vote_count()      # All votes
+
+      def vote_count(for_or_against = :all)
+        v = Vote.where(:voter_id => id).where(:voter_type => self.class.base_class.name)
+        v = case for_or_against
+          when :all   then v
+          when :up    then v.where(:vote => true)
+          when :down  then v.where(:vote => false)
+        end
+        v.count
+      end
+
+      def voted_for?(voteable)
+        voted_which_way?(voteable, :up)
+      end
+
+      def voted_against?(voteable)
+        voted_which_way?(voteable, :down)
+      end
+
+      def voted_on?(voteable)
+        0 < Vote.where(
+              :voter_id => self.id,
+              :voter_type => self.class.base_class.name,
+              :voteable_id => voteable.id,
+              :voteable_type => voteable.class.base_class.name
+            ).count
+      end
+
+      def vote_for(voteable)
+        self.vote(voteable, { :direction => :up, :exclusive => false })
+      end
+
+      def vote_against(voteable)
+        self.vote(voteable, { :direction => :down, :exclusive => false })
+      end
+
+      def vote_exclusively_for(voteable)
+        self.vote(voteable, { :direction => :up, :exclusive => true })
+      end
+
+      def vote_exclusively_against(voteable)
+        self.vote(voteable, { :direction => :down, :exclusive => true })
+      end
+
+      def vote(voteable, options = {})
+        raise ArgumentError, "you must specify :up or :down in order to vote" unless options[:direction] && [:up, :down].include?(options[:direction].to_sym)
+        if options[:exclusive]
+          self.unvote_for(voteable)
+        end
+        direction = (options[:direction].to_sym == :up)
+        # create! does not return the created object
+        v = Vote.new(:vote => direction, :voteable => voteable, :voter => self)
+        v.save!
+        v
+      end
+
+      def unvote_for(voteable)
+        Vote.where(
+          :voter_id => self.id,
+          :voter_type => self.class.base_class.name,
+          :voteable_id => voteable.id,
+          :voteable_type => voteable.class.base_class.name
+        ).map(&:destroy)
+      end
+
+      alias_method :clear_votes, :unvote_for
+
+      def voted_which_way?(voteable, direction)
+        raise ArgumentError, "expected :up or :down" unless [:up, :down].include?(direction)
+        0 < Vote.where(
+              :voter_id => self.id,
+              :voter_type => self.class.base_class.name,
+              :vote => direction == :up ? true : false,
+              :voteable_id => voteable.id,
+              :voteable_type => voteable.class.base_class.name
+            ).count
+      end
+
+      def voted_how?(voteable)
+        votes = Vote.where(
+              :voter_id => self.id,
+              :voter_type => self.class.base_class.name,
+              :voteable_id => voteable.id,
+              :voteable_type => voteable.class.base_class.name
+            ).map(&:vote) #in case votes is premitted to be duplicated
+        if votes.count == 1
+          votes.first
+        elsif votes.count == 0
+          nil
+        else
+          votes
+        end
+      end
+
+    end
+  end
+end

data/lib/formal-vote/version.rb

@@ -0,0 +1,3 @@
+module FormalVote
+  VERSION = "0.0.1"
+end

data/lib/formal_vote.rb

@@ -0,0 +1,34 @@
+require 'acts_as_voteable'
+require 'acts_as_voter'
+require 'formal_vote/configuration'
+require 'formal_vote/base'
+require "formal_vote/version"
+
+module FormalVote
+  class << self
+
+    # An ThumbsUp::Configuration object. Must act like a hash and return sensible
+    # values for all ThumbsUp::Configuration::OPTIONS. See ThumbsUp::Configuration.
+    attr_writer :configuration
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   ThumbsUp.configure do |config|
+    #     config.voteable_relationship_name = :votes_on
+    #     config.voter_relationship_name    = :votes_by
+    #   end
+    def configure
+      yield(configuration)
+    end
+
+    # The configuration object.
+    # @see ThumbsUp::Configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, FormalVote::ActsAsVoteable)
+ActiveRecord::Base.send(:include, FormalVote::ActsAsVoter)

data/lib/generators/formal_vote/formal_vote_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators/active_record'
+
+class FormalVoteGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  class_option :unique_voting, :type => :boolean, :default => true, :desc => 'Do you want only one vote allowed per voter? (default: true)'
+
+  # Implement the required interface for Rails::Generators::Migration.
+  def self.next_migration_number(dirname) #:nodoc:
+    next_migration_number = current_migration_number(dirname) + 1
+    if ActiveRecord::Base.timestamped_migrations
+      [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+    else
+      "%.3d" % next_migration_number
+    end
+  end
+
+  def create_migration
+    migration_template 'migration.rb', File.join('db', 'migrate', 'formal_vote_migration.rb')
+  end
+
+  def move_vote_model
+    template 'vote.rb', File.join('app', 'models', 'vote.rb')
+  end
+
+end

data/lib/generators/formal_vote/templates/migration.rb

@@ -0,0 +1,25 @@
+class FormalVoteMigration < ActiveRecord::Migration
+  def self.up
+    create_table :votes, :force => true do |t|
+
+      t.boolean    :vote,     :default => false,    :null => 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]
+
+<% if options[:unique_voting] == true %>
+    # 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'
+<% end %>
+  end
+
+  def self.down
+    drop_table :votes
+  end
+
+end

data/lib/generators/formal_vote/templates/vote.rb

@@ -0,0 +1,17 @@
+class Vote < ActiveRecord::Base
+
+  scope :for_voter, lambda { |*args| where(["voter_id = ? AND voter_type = ?", args.first.id, args.first.class.base_class.name]) }
+  scope :for_voteable, lambda { |*args| where(["voteable_id = ? AND voteable_type = ?", args.first.id, args.first.class.base_class.name]) }
+  scope :recent, lambda { |*args| where(["created_at > ?", (args.first || 2.weeks.ago)]) }
+  scope :descending, lambda { order("created_at DESC") }
+
+  belongs_to :voteable, :polymorphic => true
+  belongs_to :voter, :polymorphic => true
+
+  attr_accessible :vote, :voter, :voteable if ActiveRecord::VERSION::MAJOR < 4
+
+<% if options[:unique_voting] == true %>
+  # Comment out the line below to allow multiple votes per user.
+  validates_uniqueness_of :voteable_id, :scope => [:voteable_type, :voter_type, :voter_id]
+<% end %>
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: formal-vote
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Sharman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A voting library providing methods for a user to vote for, against, or
+  abstain on a model
+email:
+- benwebdev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- formal-vote.gemspec
+- lib/acts_as_votable.rb
+- lib/acts_as_voter.rb
+- lib/formal-vote/version.rb
+- lib/formal_vote.rb
+- lib/generators/formal_vote/formal_vote_generator.rb
+- lib/generators/formal_vote/templates/migration.rb
+- lib/generators/formal_vote/templates/vote.rb
+- lib/test/formal_vote_test.rb
+- lib/test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: Formal voting library
+test_files: []