rateit 1.0.5.alpha

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"      
+
+gem 'jquery-rails'
+
+# Specify your gem's dependencies in ka-rate.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    rateme (1.0.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionpack (3.2.2)
+      activemodel (= 3.2.2)
+      activesupport (= 3.2.2)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.1)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.2)
+      activesupport (= 3.2.2)
+      builder (~> 3.0.0)
+    activesupport (3.2.2)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    builder (3.0.0)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.3)
+    jquery-rails (2.0.1)
+      railties (< 5.0, >= 3.2.0)
+      thor (~> 0.14)
+    json (1.6.5)
+    multi_json (1.1.0)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    railties (3.2.2)
+      actionpack (= 3.2.2)
+      activesupport (= 3.2.2)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (!= 1.3.0, ~> 1.1)
+    thor (0.14.6)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jquery-rails
+  rateme!

data/README.md

@@ -0,0 +1,89 @@
+# Rateit Rating Gem  
+
+Provides the best way to add rating capabilites to your Rails application with jQuery Raty plugin.
+
+## Repository
+
+Find it at [github.com/muratguzel/rateit](github.com/muratguzel/rateit)
+
+## Instructions
+
+### Install
+
+You can add the rateit gem into your Gemfile
+
+	gem 'rateit'
+	
+### Generate
+
+	rails g rateit User
+
+The generator takes one argument which is the name of your existing devise user model UserModelName. This is necessary to bind the user and rating datas.
+Also the generator copies necessary files (jquery raty plugin files, star icons and javascripts)
+
+Example: 
+
+Suppose you will have a devise user model which name is User. The generator should be like below
+
+	rails g devise:install
+	rails g devise user
+	rails g rateit user # => This is rateit generator. 
+   
+This generator will create Rate and RatingCache models and link to your user model. 
+
+### Prepare
+
+I suppose you have a car model 
+
+	rails g model car name:string
+
+You should add the rateit_rateable function with its dimensions option.
+
+	class Car < ActiveRecord::Base
+		rateit_rateable :dimensions => [:speed, :engine, :price]
+	end                                                         
+	
+Then you need to add a call rateit_rater in the user model. 
+
+	class User < ActiveRecord::Base
+		rateit_rater
+	end   
+	
+	
+### Using
+
+There is a helper method which name is rating_for to add the star links. By default rating_for will display the average rating and accept the 
+new rating value from authenticated user. 
+
+	#show.html.erb -> /cars/1
+	
+	Speed : <%= rating_for @car, "speed" %>
+	Engine : <%= rating_for @car, "engine" %>
+	Price : <%= rating_for @car, "price" %>
+   
+### Important 
+
+By default rating_for tries to call current_user method as the rater instance in the rater_controller.rb file. You can change the current_user method 
+as you will.
+
+	#rater_controller.rb
+	
+	def create                                  
+    	if current_user.present?
+	      obj = eval "#{params[:klass]}.find(#{params[:id]})"     
+	      if params[:dimension].present?
+	        obj.rate params[:score].to_i, current_user.id, "#{params[:dimension]}"       
+	      else
+	        obj.rate params[:score].to_i, current_user.id 
+	      end
+
+	      render :json => true 
+	    else
+	      render :json => false        
+	    end
+	end   
+     
+## Feedback
+If you find bugs please open a ticket at [github.com/muratguzel/rateit/issues](github.com/muratguzel/rateit/issues)
+	
+	

data/Rakefile

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

data/lib/generators/rateit/rateit_generator.rb

@@ -0,0 +1,49 @@
+require 'rails/generators/migration'
+class RateitGenerator < Rails::Generators::NamedBase
+  include Rails::Generators::Migration
+  
+  source_root File.expand_path('../templates', __FILE__)      
+                                                       
+  desc "copying jquery.raty files to assets directory ..."
+  def copying
+    copy_file 'jquery.raty.js', 'app/assets/javascripts/jquery.raty.js'
+    copy_file 'star-on.png', 'app/assets/images/star-on.png'
+    copy_file 'star-off.png', 'app/assets/images/star-off.png'
+    copy_file 'star-half.png', 'app/assets/images/star-half.png'
+    copy_file 'rateit.js', 'app/assets/javascripts/rateit.js.erb'
+    copy_file 'rater_controller.rb', 'app/controllers/rater_controller.rb'
+  end         
+  
+  desc "model is creating..."
+  def create_model     
+    model_file = File.join('app/models', "#{file_path}.rb")
+    raise "User model (#{model_file}) must exits." unless File.exists?(model_file)
+    class_collisions 'Rate'
+    template 'model.rb', File.join('app/models', "rate.rb")    
+    template 'cache_model.rb', File.join('app/models', "rating_cache.rb")
+  end                                                                           
+  
+  def add_rate_path_to_route
+    route "match '/rate' => 'rater#create', :as => 'rate'"
+  end
+
+  desc "cacheable rating average migration is creating ..."
+  def create_cacheable_migration
+    migration_template "cache_migration.rb", "db/migrate/create_rating_caches.rb"
+  end
+         
+  desc "migration is creating ..."
+  def create_migration
+    migration_template "migration.rb", "db/migrate/create_rates.rb"    
+  end   
+  
+  
+  private 
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S%L")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end    
+  end
+end

data/lib/generators/rateit/templates/cache_migration.rb

@@ -0,0 +1,19 @@
+class CreateRatingCaches < ActiveRecord::Migration
+  
+  def self.up
+      create_table :rating_caches do |t|
+        t.belongs_to :cacheable, :polymorphic => true
+        t.float :avg, :null => false  
+        t.integer :qty, :null => false
+        t.string :dimension
+        t.timestamps
+      end
+
+      add_index :rating_caches, [:cacheable_id, :cacheable_type]
+    end
+
+    def self.down
+      drop_table :rating_caches
+    end  
+    
+end

data/lib/generators/rateit/templates/cache_model.rb

@@ -0,0 +1,3 @@
+class RatingCache < ActiveRecord::Base
+  belongs_to :cacheable, :polymorphic => true 
+end

data/lib/generators/rateit/templates/jquery.raty.js

@@ -0,0 +1,464 @@
+/*!
+ * jQuery Raty - A Star Rating Plugin - http://wbotelhos.com/raty
+ * -------------------------------------------------------------------
+ *
+ * jQuery Raty is a plugin that generates a customizable star rating.
+ *
+ * Licensed under The MIT License
+ *
+ * @version        2.4.5
+ * @since          2010.06.11
+ * @author         Washington Botelho
+ * @documentation  wbotelhos.com/raty
+ * @twitter        twitter.com/wbotelhos
+ *
+ * Usage:
+ * -------------------------------------------------------------------
+ * $('#star').raty();
+ *
+ * <div id="star"></div>
+ *
+ */
+
+;(function($) {
+
+	var methods = {
+		init: function(settings) {
+			return this.each(function() {
+				var self	= this,
+					$this	= $(self).empty();
+	
+				self.opt = $.extend(true, {}, $.fn.raty.defaults, settings);
+
+				$this.data('settings', self.opt);
+
+				if (typeof self.opt.number == 'function') {
+					self.opt.number = self.opt.number.call(self);
+				} else {
+					self.opt.number = methods.between(self.opt.number, 0, 20)
+				}
+
+				if (self.opt.path.substring(self.opt.path.length - 1, self.opt.path.length) != '/') {
+					self.opt.path += '/';
+				}
+
+				if (typeof self.opt.score == 'function') {
+					self.opt.score = self.opt.score.call(self);
+				}
+
+				if (self.opt.score) {
+					self.opt.score = methods.between(self.opt.score, 0, self.opt.number);					
+				}
+
+				for (var i = 1; i <= self.opt.number; i++) {
+					$('<img />', {
+						src		: self.opt.path + ((!self.opt.score || self.opt.score < i) ? self.opt.starOff : self.opt.starOn),
+						alt		: i,
+						title	: (i <= self.opt.hints.length && self.opt.hints[i - 1] !== null) ? self.opt.hints[i - 1] : i
+					}).appendTo(self);
+
+					if (self.opt.space) {
+						$this.append((i < self.opt.number) ? '&#160;' : '');
+					}
+				}
+
+				self.stars = $this.children('img:not(".raty-cancel")');
+				self.score = $('<input />', { type: 'hidden', name: self.opt.scoreName }).appendTo(self);
+
+				if (self.opt.score && self.opt.score > 0) {
+					self.score.val(self.opt.score);
+					methods.roundStar.call(self, self.opt.score);
+				}
+
+				if (self.opt.iconRange) {
+					methods.fill.call(self, self.opt.score);	
+				}
+
+				methods.setTarget.call(self, self.opt.score, self.opt.targetKeep);
+
+				var space	= self.opt.space ? 4 : 0,
+					width	= self.opt.width || (self.opt.number * self.opt.size + self.opt.number * space);
+
+				if (self.opt.cancel) {
+					self.cancel = $('<img />', { src: self.opt.path + self.opt.cancelOff, alt: 'x', title: self.opt.cancelHint, 'class': 'raty-cancel' });
+
+					if (self.opt.cancelPlace == 'left') {
+						$this.prepend('&#160;').prepend(self.cancel);
+					} else {
+						$this.append('&#160;').append(self.cancel);
+					}
+
+					width += (self.opt.size + space);
+				}
+
+				if (self.opt.readOnly) {
+					methods.fixHint.call(self);
+
+					if (self.cancel) {
+						self.cancel.hide();
+					}
+				} else {
+					$this.css('cursor', 'pointer');
+
+					methods.bindAction.call(self);
+				}
+
+				$this.css('width', width);
+			});
+		}, between: function(value, min, max) {
+			return Math.min(Math.max(parseFloat(value), min), max);
+		}, bindAction: function() {
+			var self	= this,
+				$this	= $(self);
+
+			$this.mouseleave(function() {
+				var score = self.score.val() || undefined;
+
+				methods.initialize.call(self, score);
+				methods.setTarget.call(self, score, self.opt.targetKeep);
+
+				if (self.opt.mouseover) {
+					self.opt.mouseover.call(self, score);
+				}
+			});
+
+			var action = self.opt.half ? 'mousemove' : 'mouseover';
+
+			if (self.opt.cancel) {
+				self.cancel.mouseenter(function() {
+					$(this).attr('src', self.opt.path + self.opt.cancelOn);
+
+					self.stars.attr('src', self.opt.path + self.opt.starOff);
+
+					methods.setTarget.call(self, null, true);
+
+					if (self.opt.mouseover) {
+						self.opt.mouseover.call(self, null);
+					}
+				}).mouseleave(function() {
+					$(this).attr('src', self.opt.path + self.opt.cancelOff);
+
+					if (self.opt.mouseover) {
+						self.opt.mouseover.call(self, self.score.val() || null);
+					}
+				}).click(function(evt) {
+					self.score.removeAttr('value');
+
+					if (self.opt.click) {
+			          self.opt.click.call(self, null, evt);
+			        }
+				});
+			}
+
+			self.stars.bind(action, function(evt) {
+				var value = parseInt(this.alt, 10);
+
+				if (self.opt.half) {
+					var position	= parseFloat((evt.pageX - $(this).offset().left) / self.opt.size),
+						diff		= (position > .5) ? 1 : .5;
+
+					value = parseFloat(this.alt) - 1 + diff;
+
+					methods.fill.call(self, value);
+
+					if (self.opt.precision) {
+						value = value - diff + position;
+					}
+
+					methods.showHalf.call(self, value);
+				} else {
+					methods.fill.call(self, value);
+				}
+
+				$this.data('score', value);
+
+				methods.setTarget.call(self, value, true);
+
+				if (self.opt.mouseover) {
+					self.opt.mouseover.call(self, value, evt);
+				}
+			}).click(function(evt) {
+				self.score.val((self.opt.half || self.opt.precision) ? $this.data('score') : this.alt);
+
+				if (self.opt.click) {
+					self.opt.click.call(self, self.score.val(), evt);
+				}
+			});
+		}, cancel: function(isClick) {
+			return $(this).each(function() {
+				var self	= this, 
+					$this	= $(self);
+
+				if ($this.data('readonly') === true) {
+					return this;
+				}
+
+				if (isClick) {
+					methods.click.call(self, null);
+				} else {
+					methods.score.call(self, null);
+				}
+
+				self.score.removeAttr('value');
+			});
+		}, click: function(score) {
+			return $(this).each(function() {
+				if ($(this).data('readonly') === true) {
+					return this;
+				}
+
+				methods.initialize.call(this, score);
+
+				if (this.opt.click) {
+					this.opt.click.call(this, score);
+				} else {
+					methods.error.call(this, 'you must add the "click: function(score, evt) { }" callback.');
+				}
+
+				methods.setTarget.call(this, score, true);
+			});
+		}, error: function(message) {
+			$(this).html(message);
+
+			$.error(message);
+		}, fill: function(score) {
+			var self	= this,
+				number	= self.stars.length,
+				count	= 0,
+				$star	,
+				star	,
+				icon	;
+
+			for (var i = 1; i <= number; i++) {
+				$star = self.stars.eq(i - 1);
+
+				if (self.opt.iconRange && self.opt.iconRange.length > count) {
+					star = self.opt.iconRange[count];
+
+					if (self.opt.single) {
+						icon = (i == score) ? (star.on || self.opt.starOn) : (star.off || self.opt.starOff);
+					} else {
+						icon = (i <= score) ? (star.on || self.opt.starOn) : (star.off || self.opt.starOff);
+					}
+
+					if (i <= star.range) {
+						$star.attr('src', self.opt.path + icon);
+					}
+
+					if (i == star.range) {
+						count++;
+					}
+				} else {
+					if (self.opt.single) {
+						icon = (i == score) ? self.opt.starOn : self.opt.starOff;
+					} else {
+						icon = (i <= score) ? self.opt.starOn : self.opt.starOff;
+					}
+
+					$star.attr('src', self.opt.path + icon);
+				}
+			}
+		}, fixHint: function() {
+			var $this	= $(this),
+				score	= parseInt(this.score.val(), 10),
+				hint	= this.opt.noRatedMsg;
+
+			if (!isNaN(score) && score > 0) {
+				hint = (score <= this.opt.hints.length && this.opt.hints[score - 1] !== null) ? this.opt.hints[score - 1] : score;
+			}
+
+			$this.data('readonly', true).css('cursor', 'default').attr('title', hint);
+
+			this.score.attr('readonly', 'readonly');
+			this.stars.attr('title', hint);
+		}, getScore: function() {
+			var score	= [],
+				value	;
+
+			$(this).each(function() {
+				value = this.score.val();
+
+				score.push(value ? parseFloat(value) : undefined);
+			});
+
+			return (score.length > 1) ? score : score[0];
+		}, readOnly: function(isReadOnly) {
+			return this.each(function() {
+				var $this = $(this);
+
+				if ($this.data('readonly') === isReadOnly) {
+					return this;
+				}
+
+				if (this.cancel) {
+					if (isReadOnly) {
+						this.cancel.hide();
+					} else {
+						this.cancel.show();
+					}
+				}
+
+				if (isReadOnly) {
+					$this.unbind();
+
+					$this.children('img').unbind();
+
+					methods.fixHint.call(this);
+				} else {
+					methods.bindAction.call(this);
+					methods.unfixHint.call(this);
+				}
+
+				$this.data('readonly', isReadOnly);
+			});
+		}, reload: function() {
+			return methods.set.call(this, {});
+		}, roundStar: function(score) {
+			var diff = (score - Math.floor(score)).toFixed(2);
+
+			if (diff > this.opt.round.down) {
+				var icon = this.opt.starOn;								// Full up: [x.76 .. x.99]
+
+				if (diff < this.opt.round.up && this.opt.halfShow) {	// Half: [x.26 .. x.75]
+					icon = this.opt.starHalf;
+				} else if (diff < this.opt.round.full) {				// Full down: [x.00 .. x.5]
+					icon = this.opt.starOff;
+				}
+
+				this.stars.eq(Math.ceil(score) - 1).attr('src', this.opt.path + icon);
+			}															// Full down: [x.00 .. x.25]
+		}, score: function() {
+			return arguments.length ? methods.setScore.apply(this, arguments) : methods.getScore.call(this);
+		}, set: function(settings) {
+			this.each(function() {
+				var $this	= $(this),
+					actual	= $this.data('settings'),
+					clone	= $this.clone().removeAttr('style').insertBefore($this);
+
+				$this.remove();
+
+				clone.raty($.extend(actual, settings));
+			});
+
+			return $(this.selector);
+		}, setScore: function(score) {
+			return $(this).each(function() {
+				if ($(this).data('readonly') === true) {
+					return this;
+				}
+
+				methods.initialize.call(this, score);
+				methods.setTarget.call(this, score, true);
+			});
+		}, setTarget: function(value, isKeep) {
+			if (this.opt.target) {
+				var $target = $(this.opt.target);
+
+				if ($target.length == 0) {
+					methods.error.call(this, 'target selector invalid or missing!');
+				}
+
+				var score = value;
+
+				if (!isKeep || score === undefined) {
+					score = this.opt.targetText;
+				} else {
+					if (this.opt.targetType == 'hint') {
+						score = (score === null && this.opt.cancel)
+								? this.opt.cancelHint
+								: this.opt.hints[Math.ceil(score - 1)];
+					} else {
+						score = this.opt.precision
+								? parseFloat(score).toFixed(1)
+								: score;
+					}
+				}
+
+				if (this.opt.targetFormat.indexOf('{score}') < 0) {
+					methods.error.call(this, 'template "{score}" missing!');
+				}
+
+				if (value !== null) {
+					score = this.opt.targetFormat.toString().replace('{score}', score);
+				}
+
+				if ($target.is(':input')) {
+					$target.val(score);
+				} else {
+					$target.html(score);
+				}
+			}
+		}, showHalf: function(score) {
+			var diff = (score - Math.floor(score)).toFixed(1);
+
+			if (diff > 0 && diff < .6) {
+				this.stars.eq(Math.ceil(score) - 1).attr('src', this.opt.path + this.opt.starHalf);
+			}
+		}, initialize: function(score) {
+			score = !score ? 0 : methods.between(score, 0, this.opt.number);
+
+			methods.fill.call(this, score);
+
+			if (score > 0) {
+				if (this.opt.halfShow) {
+					methods.roundStar.call(this, score);
+				}
+
+				this.score.val(score);
+			}
+		}, unfixHint: function() {
+			for (var i = 0; i < this.opt.number; i++) {
+				this.stars.eq(i).attr('title', (i < this.opt.hints.length && this.opt.hints[i] !== null) ? this.opt.hints[i] : i);
+			}
+
+			$(this).data('readonly', false).css('cursor', 'pointer').removeAttr('title');
+
+			this.score.attr('readonly', 'readonly');
+		}
+	};
+
+	$.fn.raty = function(method) {
+		if (methods[method]) {
+			return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+		} else if (typeof method === 'object' || !method) {
+			return methods.init.apply(this, arguments);
+		} else {
+			$.error('Method ' + method + ' does not exist!');
+		} 
+	};
+
+	$.fn.raty.defaults = {
+		cancel			: false,
+		cancelHint		: 'cancel this rating!',
+		cancelOff		: 'cancel-off.png',
+		cancelOn		: 'cancel-on.png',
+		cancelPlace		: 'left',
+		click			: undefined,
+		half			: false,
+		halfShow		: true,
+		hints			: ['bad', 'poor', 'regular', 'good', 'gorgeous'],
+		iconRange		: undefined,
+		mouseover		: undefined,
+		noRatedMsg		: 'not rated yet',
+		number			: 5,
+		path			: 'img/',
+		precision		: false,
+		round			: { down: .25, full: .6, up: .76 },
+		readOnly		: false,
+		score			: undefined,
+		scoreName		: 'score',
+		single			: false,
+		size			: 16,
+		space			: true,
+		starHalf		: 'star-half.png',
+		starOff			: 'star-off.png',
+		starOn			: 'star-on.png',
+		target			: undefined,
+		targetFormat	: '{score}',
+		targetKeep		: false,
+		targetText		: '',
+		targetType		: 'hint',
+		width			: undefined
+	};
+
+})(jQuery);

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

@@ -0,0 +1,20 @@
+class CreateRates < ActiveRecord::Migration
+  
+  def self.up
+      create_table :rates do |t|
+        t.belongs_to :rater
+        t.belongs_to :rateable, :polymorphic => true
+        t.float :stars, :null => false
+        t.string :dimension
+        t.timestamps
+      end
+
+      add_index :rates, :rater_id
+      add_index :rates, [:rateable_id, :rateable_type]
+    end
+
+    def self.down
+      drop_table :rates
+    end  
+    
+end

data/lib/generators/rateit/templates/model.rb

@@ -0,0 +1,7 @@
+class Rate < ActiveRecord::Base
+  belongs_to :rater, :class_name => "<%= file_name.classify %>"
+  belongs_to :rateable, :polymorphic => true
+  
+  attr_accessible :rate, :dimension
+  
+end

data/lib/generators/rateit/templates/rateit.js

@@ -0,0 +1,27 @@
+$.fn.raty.defaults.path = "/assets"; 
+$.fn.raty.defaults.half_show = true;  
+ 
+$(function(){ 
+	$(".star").raty({			       
+		score: function(){
+			return $(this).attr('data-rating')				
+		}, 
+		number: function() {
+			return $(this).attr('data-star-count')
+		},
+		click: function(score, evt) {
+		   	$.post('<%= Rails.application.class.routes.url_helpers.rate_path %>', 
+				{
+					score: score, 
+					dimension: $(this).attr('data-dimension'),  
+					id: $(this).attr('data-id'),
+					klass: $(this).attr('data-classname')
+				}, 
+				function(data) {
+			  		if(data) {
+						// success code goes here ... 
+					}
+			});
+		}                        
+	});           
+});

data/lib/generators/rateit/templates/rater_controller.rb

@@ -0,0 +1,19 @@
+class RaterController < ApplicationController 
+  
+  def create                                  
+    if current_user.present?
+      obj = eval "#{params[:klass]}.find(#{params[:id]})"     
+      if params[:dimension].present?
+        obj.rate params[:score].to_i, current_user.id, "#{params[:dimension]}"       
+      else
+        obj.rate params[:score].to_i, current_user.id 
+      end
+      
+      render :json => true 
+    else
+      render :json => false        
+    end
+  end                                        
+  
+  
+end

data/lib/rateit.rb

@@ -0,0 +1,7 @@
+require "rateit/version" 
+require "rateit/model" 
+require "rateit/helpers" 
+
+module Rateit
+    
+end

data/lib/rateit/helpers.rb

@@ -0,0 +1,29 @@
+module Helpers  
+  def rating_for(rateable_obj, dimension=nil, options={})                             
+ 
+    if dimension.nil?
+      klass = rateable_obj.average
+    else             
+      klass = rateable_obj.average "#{dimension}"    
+    end
+    
+    if klass.nil?
+      avg = 0
+    else
+      avg = klass.avg
+    end
+    
+    star = options[:star] || 5
+    
+    content_tag :div, "", "data-dimension" => dimension, :class => "star", "data-rating" => avg, 
+                          "data-id" => rateable_obj.id, "data-classname" => rateable_obj.class.name,
+                          "data-star-count" => star           
+    
+    
+  end
+     
+end
+
+class ActionView::Base
+  include Helpers
+end

data/lib/rateit/model.rb

@@ -0,0 +1,102 @@
+require 'active_support/concern'
+module Rateit
+  extend ActiveSupport::Concern
+  
+
+  def rate(stars, user_id, dimension=nil)
+    if can_rate? user_id, dimension
+      rates(dimension).build do |r|
+        r.stars = stars
+        r.rater_id = user_id
+        r.save!          
+      end      
+      update_rate_average(stars, dimension)
+    else
+      raise "User has already rated."                       
+    end
+  end 
+  
+  def update_rate_average(stars, dimension=nil)
+    if average(dimension).nil?
+      RatingCache.create do |avg|
+        avg.cacheable_id = self.id
+        avg.cacheable_type = self.class.name
+        avg.avg = stars
+        avg.qty = 1
+        avg.dimension = dimension
+        avg.save!
+      end               
+    else
+      a = average(dimension)
+      a.avg = (a.avg + stars) / (a.qty+1)
+      a.qty = a.qty + 1
+      a.save!
+    end   
+  end                               
+  
+  def average(dimension=nil)
+    if dimension.nil?
+      self.send "rate_average_without_dimension"
+    else
+      self.send "#{dimension}_average"
+    end      
+  end        
+      
+  def can_rate?(user_id, dimension=nil)
+    val = self.connection.select_value("select count(*) as cnt from rates where rateable_id=#{self.id} and rateable_type='#{self.class.name}' and rater_id=#{user_id} and dimension='#{dimension}'").to_i
+    if val == 0
+      true
+    else
+      false
+    end      
+  end    
+  
+  def rates(dimension=nil)
+    if dimension.nil?
+      self.send "rates_without_dimension"
+    else
+      self.send "#{dimension}_rates"
+    end
+  end
+  
+  def raters(dimension=nil)
+    if dimension.nil?
+      self.send "raters_without_dimension"
+    else
+      self.send "#{dimension}_raters"
+    end      
+  end
+
+  module ClassMethods
+    
+    def rateit_rater
+      has_many :ratings_given, :class_name => "Rate", :foreign_key => :rater_id       
+    end    
+    
+    def rateit_rateable(*dimensions)
+      has_many :rates_without_dimension, :as => :rateable, :class_name => "Rate", :dependent => :destroy, :conditions => {:dimension => nil}
+      has_many :raters_without_dimension, :through => :rates_without_dimension, :source => :rater  
+      
+      has_one :rate_average_without_dimension, :as => :cacheable, :class_name => "RatingCache", 
+              :dependent => :destroy, :conditions => {:dimension => nil}
+      
+
+      dimensions.each do |dimension|        
+        has_many "#{dimension}_rates", :dependent => :destroy, 
+                                       :conditions => {:dimension => dimension.to_s}, 
+                                       :class_name => "Rate", 
+                                       :as => :rateable
+                                       
+        has_many "#{dimension}_raters", :through => "#{dimension}_rates", :source => :rater         
+        
+        has_one "#{dimension}_average", :as => :cacheable, :class_name => "RatingCache", 
+                                        :dependent => :destroy, :conditions => {:dimension => dimension.to_s}
+      end                                                    
+    end
+  end
+    
+end        
+
+class ActiveRecord::Base
+  include Rateit
+end

data/lib/rateit/version.rb

@@ -0,0 +1,3 @@
+module Rateit
+  VERSION = "1.0.5.alpha"
+end

data/rateit.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rateit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rateit"
+  s.version     = Rateit::VERSION
+  s.authors     = ["Murat GUZEL"]
+  s.email       = ["guzelmurat@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Provides the best solution to add rating functionality to your models.}
+  s.description = %q{Provides the best solution to add rating functionality to your models.}
+
+  s.rubyforge_project = "rateit"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: rateit
+version: !ruby/object:Gem::Version
+  version: 1.0.5.alpha
+  prerelease: 6
+platform: ruby
+authors:
+- Murat GUZEL
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-06 00:00:00.000000000 Z
+dependencies: []
+description: Provides the best solution to add rating functionality to your models.
+email:
+- guzelmurat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/.DS_Store
+- lib/generators/rateit/USAGE
+- lib/generators/rateit/rateit_generator.rb
+- lib/generators/rateit/templates/cache_migration.rb
+- lib/generators/rateit/templates/cache_model.rb
+- lib/generators/rateit/templates/jquery.raty.js
+- lib/generators/rateit/templates/migration.rb
+- lib/generators/rateit/templates/model.rb
+- lib/generators/rateit/templates/rateit.js
+- lib/generators/rateit/templates/rater_controller.rb
+- lib/generators/rateit/templates/star-half.png
+- lib/generators/rateit/templates/star-off.png
+- lib/generators/rateit/templates/star-on.png
+- lib/rateit.rb
+- lib/rateit/helpers.rb
+- lib/rateit/model.rb
+- lib/rateit/version.rb
+- pkg/rateit-1.0.4.alpha.gem
+- rateit-1.0.3.gem
+- rateit.gemspec
+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: 1.3.1
+requirements: []
+rubyforge_project: rateit
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Provides the best solution to add rating functionality to your models.
+test_files: []