rating_for 0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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,79 @@
+# rating_for
+
+## A context-based rating gem for Rails
+This gem allows you to add multiple different rating criteria to your ActiveRecord based model. It provides column-caching, a polymorphic association for raters and works with both Rails 2 and 3.
+
+It's a pure model gem and does not provide any view methods. Prototype, jQuery and company provide all excellent methods and plugins for this.
+
+## Installation
+Rails 2:
+
+Not supported anymore.
+
+Rails 3:
+    
+Add the gem to your Gemfile:
+    
+    gem 'rating_for'
+    
+Generate the migration to create the tables and run it:
+    
+    rails g rating_for:migration
+    rake db:migrate
+
+
+## Example
+Let's say you want to rate hotels by different criteria, like room service or quality.
+Then your model hotel.rb should look like this:
+    
+    class Hotel < ActiveRecord::Base
+      rating_for :room_service
+      rating_for :quality
+    end
+
+You can add ratings like this:
+  
+    four_seasons = Hotel.find_by_name("Four Seasons")
+    four_seasons.rating_for_quality.add(10)
+    four_seasons.rating_for_room_service.add(9)
+    
+    rating = Rating.new(:value => 7)
+    marriott = Hotel.find_by_name('Marriott')
+    marriott.rating_for_room_service << rating
+    
+You can also assign raters to your ratings,
+e.g. customers
+
+    class Customer < ActiveRecord::Base
+    end
+
+or newspapers
+    
+    class Newspaper < ActiveRecord::Base
+    end
+
+by simply adding them to your rating:
+  
+    a_customer = Customer.find(1)
+    nytimes = Newspaper.find_by_name("New York Times")
+    
+    four_seasons.rating_for_quality.add(10, a_customer)
+    marriott.rating_for_room_service << Rating.new(:rater => nytimes, :value => 8)
+    
+Search over ratings is also possible:
+
+    hotels = Hotel.find_where_quality_has_average_rating_of(10)
+    
+    hotel1 = hotels.first
+    hotel1.name
+    => "Four Seasons"
+    hotel1.avg_rating
+    => 10.0
+    
+## TODO
+ * Add more (better) query methods
+ * Add more examples
+
+## License
+Copyright (c) 2012 [Frane Bandov](http://github.com/frane), released under the MIT license
+

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

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

@@ -0,0 +1,26 @@
+require 'rails/generators'
+require 'rails/generators/migration' 
+
+module RatingFor
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc 'Generates a migration file that contains all tables that are needed by the rating_for gem'
+
+    def self.source_root
+      @source_root ||= File.expand_path('../templates', __FILE__)
+    end
+    
+    def self.next_migration_number(path)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(path) + 1)
+      end
+    end
+
+    def manifest
+      migration_template 'migration.rb', 'db/migrate/create_rating_for_tables'
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+class CreateRatingForTables < ActiveRecord::Migration
+  def self.up
+    create_table :rateable_elements do |t|
+    	t.string  :element_type
+    	t.string  :element_attribute
+    	t.integer :element_id
+    	t.float :avg_rating, :default => 0
+    	t.integer :total_rating, :default => 0
+    	t.integer :ratings_count, :default => 0
+    	
+      t.timestamps
+    end
+    
+    create_table :ratings do |t|
+      t.integer :value
+      t.integer :rateable_element_id
+      t.integer :rater_id
+      t.string  :rater_type
+      
+      t.timestamps
+    end
+    
+    add_index :ratings, :rateable_element_id
+    add_index :ratings, [:rater_type, :rater_id]
+    add_index :rateable_elements, [:element_type, :element_attribute, :element_id], :name => :rateable_elements_index
+  end
+  
+  def self.down
+    drop_table :ratings
+    drop_table :rateable_elements
+  end
+end

data/lib/rating_for/rateable_element.rb

@@ -0,0 +1,86 @@
+class RateableElement < ActiveRecord::Base
+  has_many :ratings, :dependent => :destroy
+  belongs_to :element, :polymorphic => true
+  before_save :recalculate_avg_rating
+  
+  validates_uniqueness_of :element_id, :scope => [:element_type, :element_attribute]
+  validates_associated :element
+  validates_presence_of :element_attribute
+  
+  def average_rating
+    self.avg_rating
+  end
+  
+  def average_rating=(value)
+    self.avg_rating = value
+  end
+  
+  def <<(rating)
+    self.add_rating(rating)
+  end
+  
+  def add_rating(rating)
+    return self.ratings unless rating.is_a?(Rating)
+    self.ratings << rating
+    self.total_rating += rating.value
+    self.ratings_count += 1
+    self.save
+  end
+  
+  def add(value, rater = nil)
+    self.add_rating(Rating.new(:rater => rater, :value => value))
+  end
+  
+  def remove_rating(rating)
+    return self.ratings unless rating.is_a?(Rating)
+    self.total_rating -= rating.value
+    self.ratings_count -= 1
+    rating.destroy 
+    self.save
+  end
+  
+  def remove_by_rater(rater)
+    self.ratings.find_all_by_rater_id(rater.id, :conditions => {:rater_type => rater.class.name}).each do |rating|
+      self.remove_rating(rating)
+    end
+  end
+  
+  def clear
+    self.ratings = []
+    self.recalculate_rating
+  end
+  
+  def remove_all
+    self.clear
+  end
+  
+  def rated_by?(rater)
+    not self.ratings.find_all_by_rater_id(rater.id, :conditions => {:rater_type => rater.class.name}).empty?
+  end
+  
+  def recalculate_rating
+    self.recalculate_rating_without([])
+  end
+  
+  def recalculate_rating_without(ratings)
+    return unless (ratings.is_a? Rating or ratings.is_a? Array)
+
+    self.total_rating = 0
+    self.ratings_count = 0
+    self.avg_rating = 0
+    ratings = self.ratings - [ratings].compact.flatten
+    ratings.each do |r|
+      self.total_rating += r.value
+      self.ratings_count += 1 
+    end
+    self.save
+  end
+
+  private
+
+  def recalculate_avg_rating
+    self.avg_rating = self.total_rating.to_f / self.ratings_count
+    self.avg_rating = 0 if self.avg_rating.nan?
+  end
+
+end

data/lib/rating_for/rating.rb

@@ -0,0 +1,37 @@
+class Rating < ActiveRecord::Base
+  belongs_to :rateable_element
+  belongs_to :rater, :polymorphic => true
+
+  validates_associated :rateable_element
+  validates_presence_of :value
+  
+  after_destroy :update_rateable_element
+  after_update :update_rateable_element
+  
+  def rated_element
+    self.rateable_element.element
+  end
+  
+  def rating_for
+    self.rateable_element.element_attribute
+  end
+  
+  def rating_for?(element)
+    element.to_s == self.rating_for
+  end
+  
+  def is_for
+    self.rating_for
+  end
+  
+  def is_for?(element)
+    self.rating_for?(element)
+  end
+  
+  protected
+  
+  def update_rateable_element
+    self.rateable_element.recalculate_rating
+  end
+  
+end

data/lib/rating_for/version.rb

@@ -0,0 +1,3 @@
+module RatingFor
+  VERSION = "0.2"
+end

data/lib/rating_for.rb

@@ -0,0 +1,88 @@
+require "rating_for/version"
+require "rating_for/rateable_element"
+require "rating_for/rating"
+
+module RatingFor
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def rating_for(element, options = {})
+      has_one "rating_for_#{element}", 
+              :dependent => :destroy, 
+              :as => :element,
+              :conditions => {:element_attribute => element.to_s}
+      
+      define_method "rating_for_#{element}" do
+        rateable_element = instance_variable_get("@_rating_for_#{element}")
+        
+        if rateable_element.nil?
+          rateable_element = RateableElement.find_by_element_id(self.id, :conditions => {:element_type => self.class.name, :element_attribute => element.to_s})
+          rateable_element = RateableElement.new(:element_id => self.id, :element_type => self.class.name, :element_attribute => element.to_s) if rateable_element.nil?
+          instance_variable_set("@_rating_for_#{element}", rateable_element)
+        end
+        
+        rateable_element
+      end
+
+      (class << self; self; end).module_eval do
+        define_method "find_where_#{element}_has_average_rating_of" do |value|
+          self.find_with_average_rating_of(element.to_s, value)
+        end
+      end
+      
+      (class << self; self; end).module_eval do
+        define_method "find_where_#{element}_has_total_rating_of" do |value|
+          self.find_with_average_rating_of(element.to_s, value)
+        end
+      end
+      
+      (class << self; self; end).module_eval do
+        define_method "find_where_#{element}_has_ratings_count_of" do |value|
+          self.find_with_average_rating_of(element.to_s, value)
+        end
+      end        
+      
+      (class << self; self; end).module_eval do
+        define_method "find_where_#{element}_was_rated_by" do |rater|
+          self.find_rated_by(element.to_s, rater)
+        end
+      end
+      
+      extend RatingFor::SingletonMethods
+    end
+  end
+
+  module SingletonMethods
+    # TODO Check if this is DB-agnostic
+    def find_with_average_rating_of(element, value)
+      find :all, :conditions => "rateable_elements.element_attribute = \"#{element}\" AND rateable_elements.avg_rating = \"#{value}\"", 
+           :joins => "INNER JOIN rateable_elements ON rateable_elements.element_id = #{self.name.underscore.pluralize}.id"
+    end
+    
+    def find_with_total_rating_of(element, value)
+      find :all, :conditions => "rateable_elements.element_attribute = \"#{element}\" AND rateable_elements.total_rating = \"#{value}\"", 
+           :joins => "INNER JOIN rateable_elements ON rateable_elements.element_id = #{self.name.underscore.pluralize}.id"
+    end
+    
+    def find_with_ratings_count_of(element, value)
+      find :all, :conditions => "rateable_elements.element_attribute = \"#{element}\" AND rateable_elements.ratings_count = \"#{value}\"", 
+           :joins => "INNER JOIN rateable_elements ON rateable_elements.element_id = #{self.name.underscore.pluralize}.id"
+    end
+    
+    def find_rated_by(element, rater)
+      found_objects = []
+      Rating.find(:all, :conditions => "rater_id = #{rater.id} AND rater_type = \"#{rater.class}\" AND element_attribute = \"#{element}\"", :joins => [:rateable_element]).each do |rating|
+        found_objects << find(:first, :conditions => {:id => rating.rateable_element.element_id})
+      end
+      found_objects.compact
+    end      
+  end
+
+end
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send(:include, RatingFor)
+end

data/rating_for.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rating_for/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rating_for"
+  s.version     = RatingFor::VERSION
+  s.authors     = ["Frane Bandov"]
+  s.email       = ["frane.bandov@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A context-based rating gem for Rails}
+  s.description = %q{This plugin allows you to add multiple different rating criteria to your ActiveRecord based model. It provides column-caching and a polymorphic association for raters.}
+
+  s.rubyforge_project = "rating_for"
+
+  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"]
+
+
+  s.add_dependency 'activerecord', '~> 3.0'
+  s.add_development_dependency 'sqlite3'
+end

data/test/fixtures/hotels.yml

@@ -0,0 +1,7 @@
+four_seasons:
+    id: 1
+    name: Four Seasons
+
+hilton:
+    id: 2
+    name: hilton

data/test/fixtures/newspapers.yml

@@ -0,0 +1,4 @@
+nytimes:
+    id: 1
+    name: New York Times
+    

data/test/fixtures/users.yml

@@ -0,0 +1,7 @@
+john:
+    id: 1
+    name: John Doe
+
+jane:
+    id: 2
+    name: Jane Doe

data/test/rating_for_test.rb

@@ -0,0 +1,129 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class Hotel < ActiveRecord::Base
+  rating_for :service
+  rating_for :quality
+end
+
+class Newspaper < ActiveRecord::Base
+  rating_for :reputation
+end
+
+
+class RatingForTest < ActiveRecord::TestCase  
+  include ActiveRecord::TestFixtures
+
+  self.fixture_path = File.join(File.dirname(__FILE__), 'fixtures')
+  #self.fixture_table_names = ActiveRecord::Base.connection.tables
+  self.use_transactional_fixtures = true
+  fixtures :users, :hotels, :newspapers
+
+  ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+  test "add ratings" do
+    # init
+    hotel = Hotel.find(1)
+    user = User.find(1)
+    user2 = User.find(2)
+    newspaper = Newspaper.find(1)
+
+    # everything OK?
+    assert hotel.rating_for_quality
+    assert hotel.rating_for_service
+    assert newspaper.rating_for_reputation
+
+    # add a rating object
+    r = Rating.new(:rater => user, :value => 2)
+    hotel.rating_for_quality << r
+    assert_equal hotel.rating_for_quality.avg_rating, hotel.rating_for_quality.total_rating
+    assert_equal r.rated_element, hotel
+    assert_equal r.rating_for, "quality"
+    assert r.rating_for?(:quality) 
+    
+    # add a rating by value - preferred way 
+    hotel.rating_for_quality.add(10, user2)
+    assert_equal hotel.rating_for_quality.avg_rating, 6
+
+    hotel.rating_for_quality.add(10)
+    assert_equal hotel.rating_for_quality.avg_rating.round, 7
+
+    assert_equal hotel.rating_for_quality.ratings_count, 3
+    assert hotel.rating_for_quality.rated_by?(user2)
+    
+    # find by rating
+    hotel.rating_for_service.add(10, user)
+    assert_equal Hotel.find_where_service_has_average_rating_of(10).first, hotel
+
+    assert hotel.rating_for_service.rated_by?(user)
+    assert_equal hotel.rating_for_service.rated_by?(newspaper), false
+  end
+
+  test "remove ratings" do
+    # init
+    hotel = Hotel.find(1)
+    user = User.find(1)
+    
+    hotel.rating_for_quality.add(10)
+    hotel.rating_for_quality.add(5)
+    hotel.rating_for_quality.add(7)
+    hotel.rating_for_quality.add(2, user)
+    hotel.rating_for_quality.add(1)
+    
+    hotel.rating_for_service.add(10)
+    
+    avg_rating = hotel.rating_for_quality.avg_rating
+    
+    # everything OK?
+    h = Hotel.find_where_quality_has_average_rating_of(avg_rating).first
+    assert_equal hotel.rating_for_quality.avg_rating, h.rating_for_quality.avg_rating
+    assert_equal hotel.id, h.id
+    
+    r = Rating.find(1)
+    assert_equal 10, r.value
+    
+    # remove a rating object by calling its destroy method - not recommended
+    r.destroy
+    new_avg_rating = (5 + 7 + 2 + 1).to_f / 4
+    assert new_avg_rating != avg_rating
+    assert new_avg_rating != h.rating_for_quality.avg_rating
+    assert_equal avg_rating, h.rating_for_quality.avg_rating
+    
+    # the reference to the rating object is kept until the referring object is reloaded
+    h.rating_for_quality.reload
+    assert avg_rating != h.rating_for_quality.avg_rating
+    assert_equal new_avg_rating, h.rating_for_quality.avg_rating
+    
+    assert hotel.rating_for_quality.avg_rating != new_avg_rating
+    assert_equal avg_rating, hotel.rating_for_quality.avg_rating
+    
+    # new objects get their data fresh out of the database - this data is corect
+    h2 = Hotel.find(1)
+    assert_equal h.rating_for_quality.avg_rating, h2.rating_for_quality.avg_rating
+    assert hotel.rating_for_quality.avg_rating != h2.rating_for_quality.avg_rating
+    assert_equal new_avg_rating, h2.rating_for_quality.avg_rating
+    
+    # instead of reloading we can racalculate without the destroyed object - not recommended
+    hotel.rating_for_quality.recalculate_rating_without(r)
+    assert hotel.rating_for_quality.avg_rating != avg_rating
+    assert_equal new_avg_rating, hotel.rating_for_quality.avg_rating
+    
+    # preferred way: delete ratings through remove_rating
+    avg_rating = hotel.rating_for_quality.avg_rating
+    new_avg_rating = (7 + 2 + 1).to_r / 3
+    r = Rating.find(2)
+    
+    hotel.rating_for_quality.remove_rating(r)
+    assert avg_rating != hotel.rating_for_quality.avg_rating
+    assert_equal new_avg_rating, hotel.rating_for_quality.avg_rating
+    
+    # or through remove_by_rater
+    avg_rating = hotel.rating_for_quality.avg_rating
+    new_avg_rating = (7 + 1).to_r / 2
+    hotel.rating_for_quality.remove_by_rater user
+    assert avg_rating != hotel.rating_for_quality.avg_rating
+    assert_equal new_avg_rating, hotel.rating_for_quality.avg_rating
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'active_record'
+require 'active_record/test_case'
+require 'active_record/fixtures'
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../init'
+require File.dirname(__FILE__) + '/../lib/generators/rating_for/migration/templates/migration'
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3', :database => ':memory:'
+})
+# this is VERY important! during setting up fixtures there is checked if ActiveRecord::Base.configurations is not blank.
+ActiveRecord::Base.configurations = {:test => true}
+
+ActiveRecord::Schema.define do
+  create_table :users, :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :hotels, :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :newspapers, :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+end
+
+CreateRatingForTables.up

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rating_for
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Frane Bandov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70173126204620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70173126204620
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70173126201800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70173126201800
+description: This plugin allows you to add multiple different rating criteria to your
+  ActiveRecord based model. It provides column-caching and a polymorphic association
+  for raters.
+email:
+- frane.bandov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/rating_for/migration/migration_generator.rb
+- lib/generators/rating_for/migration/templates/migration.rb
+- lib/rating_for.rb
+- lib/rating_for/rateable_element.rb
+- lib/rating_for/rating.rb
+- lib/rating_for/version.rb
+- rating_for.gemspec
+- test/fixtures/hotels.yml
+- test/fixtures/newspapers.yml
+- test/fixtures/users.yml
+- test/rating_for_test.rb
+- test/test_helper.rb
+homepage: ''
+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: rating_for
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A context-based rating gem for Rails
+test_files:
+- test/fixtures/hotels.yml
+- test/fixtures/newspapers.yml
+- test/fixtures/users.yml
+- test/rating_for_test.rb
+- test/test_helper.rb