rating 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a11655b90d44d485ffd1f791ddb1acf2438cdb4a
-  data.tar.gz: d18accbb4c21b0a63a3a771db0e0f32db007b289
+  metadata.gz: b7eb5b802982259c2ec3101c38bbfe18302226f2
+  data.tar.gz: cce443ffafbf9887de9d9261fa5e0223ad190b47
 SHA512:
-  metadata.gz: 23142de88a5bde63875a119d0833c9321d6a351b01d9052a8c6f7a9c2c5aae4f86d6f0acea127f6c039779aca67b5bc7b63037b8ae520628d69e5946cf52393b
-  data.tar.gz: aa732a3d4c09ff0472a142c61a074590df24b8701d0898bdd39341f0622ffb80388d3198cdbc029614255d1cb4d558b4c86862fe38dcdf6f080773784ece8c25
+  metadata.gz: a29fc4b2a26a3f8cd40d3d97ad2d1691a3bd5cbd70a5bd436c9f57b5dbbb11470185a602394f6629989dda254f68aa0ff01ce4ca22c59291a1f83f81ad36cb11
+  data.tar.gz: f79ec758ff607f735e9452b45705c52eacc6df4898cc4c8826a90fa6fe7cdf86fa0cde79c67321540aa262328afede7167f471e694b7df6744e944bbc52a41ae

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## v0.2.0
+
+### News
+
+- Scope support to be possible rate item from a resource;
+- Author model type where zero rating record is not generated on record creation.
+
 ## v0.1.0
 
 - First release.

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.org/wbotelhos/rating.svg)](https://travis-ci.org/wbotelhos/rating)
 [![Gem Version](https://badge.fury.io/rb/rating.svg)](https://badge.fury.io/rb/rating)
 
-A true Bayesian rating system with cache enabled.
+A true Bayesian rating system with scope and cache enabled.
 
 ## JS Rating?
 
@@ -33,13 +33,13 @@ Rating uses the know as "True Bayesian Estimate" inspired on [IMDb rating](http:
 
 `WR`: weighted rating
 
-`R`:  average for the resource (mean) = (Rating)
+`R`:  average for the resource
 
-`v`:  number of votes for the movie = (votes)
+`v`:  number of votes for the resource
 
 `m`:  average of the number of votes
 
-`C`:  the mean vote across the whole report
+`C`:  the average rating based on all resources
 
 ## Install
 
@@ -71,7 +71,7 @@ class User < ApplicationRecord
 end
 ```
 
-Now this model can vote or be voted.
+Now this model can vote or receive votes.
 
 ### rate
 
@@ -175,6 +175,112 @@ Article.order_by_rating :average, :asc
 
 It will return a collection of resource ordered by `Rating` table data.
 
+### Scope
+
+All methods support scope query, since you may want to vote on items of a resource instead the resource itself.
+Let's say an article belongs to one or more categories and you want to vote on some categories of this article.
+
+```ruby
+category_1 = Category.first
+category_2 = Category.second
+author     = User.last
+resource   = Article.last
+```
+
+In this situation you should scope the vote of article with some category:
+
+**rate**
+
+```ruby
+author.rate resource, 3, scopeable: category_1
+author.rate resource, 5, scopeable: category_2
+```
+
+Now `article` has a rating for `category_1` and another one for `category_2`.
+
+**rating**
+
+Recovering the rating values for article, we have:
+
+```ruby
+author.rating
+# nil
+```
+
+But using the scope to make the right query:
+
+```ruby
+author.rating scope: category_1
+# { average: 3, estimate: 3, sum: 3, total: 1 }
+
+author.rating scope: category_2
+# { average: 5, estimate: 5, sum: 5, total: 1 }
+```
+
+**rated**
+
+On the same way you can find your rates with a scoped query:
+
+```ruby
+user.rated scope: category_1
+# { value: 3, scopeable: category_1 }
+```
+
+**rates**
+
+The resource still have the power to consult its rates:
+
+```ruby
+article.rates scope: category_1
+# { value: 3, scopeable: category_1 }
+
+article.rates scope: category_2
+# { value: 3, scopeable: category_2 }
+```
+
+**order_by_rating**
+
+To order the rating you do the same thing:
+
+```ruby
+Article.order_by_rating scope: category_1
+```
+
+### Records
+
+Maybe you want to recover all records with or without scope, so you can add the suffix `_records` on relations:
+
+```ruby
+category_1 = Category.first
+category_2 = Category.second
+author     = User.last
+resource   = Article.last
+
+author.rate resource, 1
+author.rate resource, 3, scopeable: category_1
+author.rate resource, 5, scopeable: category_2
+
+author.rating_records
+# { average: 1, estimate: 1, scopeable: nil       , sum: 1, total: 1 },
+# { average: 3, estimate: 3, scopeable: category_1, sum: 3, total: 1 },
+# { average: 5, estimate: 5, scopeable: category_2, sum: 5, total: 1 }
+
+user.rated_records
+# { value: 1 }, { value: 3, scopeable: category_1 }, { value: 5, scopeable: category_2 }
+
+article.rates_records
+# { value: 1 }, { value: 3, scopeable: category_1 }, { value: 5, scopeable: category_2 }
+```
+
+### As
+
+If you have a model that will only be able to rate but not to receive a rate, configure it as `author`.
+An author model still can be rated, but won't genarate a Rating record with all values as zero to be easier to display.
+
+```ruby
+rating as: :author
+```
+
 ## Love it!
 
 Via [PayPal](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=X8HEP2878NDEG&item_name=rating) or [Gratipay](https://gratipay.com/rating). Thanks! (:

data/lib/generators/rating/install_generator.rb

@@ -4,12 +4,16 @@ module Rating
   class InstallGenerator < Rails::Generators::Base
     source_root File.expand_path('../templates', __FILE__)
 
-    desc 'configure Rating'
+    desc 'creates Rating migration'
 
     def create_migration
-      version = Time.current.strftime('%Y%m%d%H%M%S')
+      template 'db/migrate/create_rating_tables.rb', "db/migrate/#{timestamp}_create_rating_tables.rb"
+    end
+
+    private
 
-      template 'db/migrate/create_rating_tables.rb', "db/migrate/#{version}_create_rating_tables.rb"
+    def timestamp
+      Time.current.strftime '%Y%m%d%H%M%S'
     end
   end
 end

data/lib/generators/rating/templates/db/migrate/create_rating_tables.rb

@@ -5,14 +5,15 @@ class CreateRatingTables < ActiveRecord::Migration[5.0]
     create_table :rating_rates do |t|
       t.decimal :value, default: 0, precision: 17, scale: 14
 
-      t.references :author  , index: true, null: false, polymorphic: true
-      t.references :resource, index: true, null: false, polymorphic: true
+      t.references :author   , index: true, null: false, polymorphic: true
+      t.references :resource , index: true, null: false, polymorphic: true
+      t.references :scopeable, index: true, null: true , polymorphic: true
 
       t.timestamps null: false
     end
 
-    add_index :rating_rates, %i[author_id author_type resource_id resource_type],
-      name:   :index_rating_rates_on_author_and_resource,
+    add_index :rating_rates, %i[author_id author_type resource_id resource_type scopeable_id scopeable_type],
+      name:   :index_rating_rates_on_author_and_resource_and_scopeable,
       unique: true
 
     create_table :rating_ratings do |t|
@@ -21,11 +22,14 @@ class CreateRatingTables < ActiveRecord::Migration[5.0]
       t.integer :sum     , default: 0, mull: false
       t.integer :total   , default: 0, mull: false
 
-      t.references :resource, index: true, null: false, polymorphic: true
+      t.references :resource , index: true, null: false, polymorphic: true
+      t.references :scopeable, index: true, null: true , polymorphic: true
 
       t.timestamps null: false
     end
 
-    add_index :rating_ratings, %i[resource_id resource_type], unique: true
+    add_index :rating_ratings, %i[resource_id resource_type scopeable_id scopeable_type],
+      name:   :index_rating_rating_on_resource_and_scopeable,
+      unique: true
   end
 end

data/lib/rating/models/rating/extension.rb

@@ -5,40 +5,59 @@ module Rating
     extend ActiveSupport::Concern
 
     included do
-      def rate(resource, value, author: self)
-        Rate.create author: author, resource: resource, value: value
+      def rate(resource, value, author: self, scope: nil)
+        Rate.create author: author, resource: resource, scopeable: scope, value: value
       end
 
-      def rate_for(resource)
-        Rate.rate_for author: self, resource: resource
+      def rate_for(resource, scope: nil)
+        Rate.rate_for author: self, resource: resource, scopeable: scope
       end
 
-      def rated?(resource)
-        !rate_for(resource).nil?
+      def rated?(resource, scope: nil)
+        !rate_for(resource, scope: scope).nil?
+      end
+
+      def rates(scope: nil)
+        rates_records.where scopeable: scope
+      end
+
+      def rated(scope: nil)
+        rated_records.where scopeable: scope
+      end
+
+      def rating(scope: nil)
+        rating_records.find_by scopeable: scope
       end
     end
 
     module ClassMethods
-      def rating
-        after_create { Rating.find_or_create_by resource: self }
+      def rating(as: nil)
+        after_create -> { Rating.find_or_create_by resource: self }, unless: -> { as == :author }
 
-        has_one :rating,
+        has_many :rating_records,
           as:         :resource,
           class_name: '::Rating::Rating',
           dependent:  :destroy
 
-        has_many :rates,
+        has_many :rates_records,
           as:         :resource,
           class_name: '::Rating::Rate',
           dependent:  :destroy
 
-        has_many :rated,
+        has_many :rated_records,
           as:         :author,
           class_name: '::Rating::Rate',
           dependent:  :destroy
 
-        scope :order_by_rating, ->(column = :estimate, direction = :desc) {
-          includes(:rating).order("#{Rating.table_name}.#{column} #{direction}")
+        scope :order_by_rating, ->(column = :estimate, direction = :desc, scope: nil) {
+          scope_values = {
+            scopeable_id:   scope&.id,
+            scopeable_type: scope&.class&.base_class&.name
+          }
+
+          includes(:rating_records)
+            .where(Rating.table_name => scope_values)
+            .order("#{Rating.table_name}.#{column} #{direction}")
         }
       end
     end

data/lib/rating/models/rating/rate.rb

@@ -6,19 +6,20 @@ module Rating
 
     after_save :update_rating
 
-    belongs_to :author  , polymorphic: true
-    belongs_to :resource, polymorphic: true
+    belongs_to :author   , polymorphic: true
+    belongs_to :resource , polymorphic: true
+    belongs_to :scopeable, polymorphic: true
 
     validates :author, :resource, :value, presence: true
     validates :value, numericality: { greater_than_or_equal_to: 1, less_than_or_equal_to: 100 }
 
     validates :author_id, uniqueness: {
       case_sensitive: false,
-      scope:          %i[author_type resource_id resource_type]
+      scope:          %i[author_type resource_id resource_type scopeable_id scopeable_type]
     }
 
-    def self.create(author:, resource:, value:)
-      record = find_or_initialize_by(author: author, resource: resource)
+    def self.create(author:, resource:, scopeable: nil, value:)
+      record = find_or_initialize_by(author: author, resource: resource, scopeable: scopeable)
 
       return record if record.persisted? && value == record.value
 
@@ -28,14 +29,14 @@ module Rating
       record
     end
 
-    def self.rate_for(author:, resource:)
-      find_by author: author, resource: resource
+    def self.rate_for(author:, resource:, scopeable: nil)
+      find_by author: author, resource: resource, scopeable: scopeable
     end
 
     private
 
     def update_rating
-      ::Rating::Rating.update_rating resource
+      ::Rating::Rating.update_rating resource, scopeable
     end
   end
 end

data/lib/rating/models/rating/rating.rb

@@ -4,30 +4,34 @@ module Rating
   class Rating < ActiveRecord::Base
     self.table_name = 'rating_ratings'
 
-    belongs_to :resource, polymorphic: true
+    belongs_to :resource , polymorphic: true
+    belongs_to :scopeable, polymorphic: true
 
     validates :average, :estimate, :resource, :sum, :total, presence: true
     validates :average, :estimate, :sum, :total, numericality: true
 
     class << self
-      def averager_data(resource)
-        total_count    = how_many_resource_received_votes_sql?
-        distinct_count = how_many_resource_received_votes_sql?(distinct: true)
+      def averager_data(resource, scopeable)
+        total_count    = how_many_resource_received_votes_sql?(distinct: false, scopeable: scopeable)
+        distinct_count = how_many_resource_received_votes_sql?(distinct: true , scopeable: scopeable)
+        values         = { resource_type: resource.class.base_class.name }
+
+        values[:scopeable_type] = scopeable.class.base_class.name unless scopeable.nil?
 
         sql = %(
           SELECT
             (#{total_count} / CAST(#{distinct_count} AS float)) count_avg,
             COALESCE(AVG(value), 0)                             rating_avg
           FROM #{rate_table_name}
-          WHERE resource_type = :resource_type
+          WHERE resource_type = :resource_type and #{scope_type_query(scopeable)}
         ).squish
 
-        execute_sql [sql, resource_type: resource.class.base_class.name]
+        execute_sql [sql, values]
       end
 
-      def data(resource)
-        averager = averager_data(resource)
-        values   = values_data(resource)
+      def data(resource, scopeable)
+        averager = averager_data(resource, scopeable)
+        values   = values_data(resource, scopeable)
 
         {
           average:  values.rating_avg,
@@ -37,22 +41,31 @@ module Rating
         }
       end
 
-      def values_data(resource)
+      def values_data(resource, scopeable)
+        scope_query = if scopeable.nil?
+                        'scopeable_type is NULL and scopeable_id is NULL'
+                      else
+                        'scopeable_type = ? and scopeable_id = ?'
+                      end
+
         sql = %(
           SELECT
             COALESCE(AVG(value), 0) rating_avg,
             COALESCE(SUM(value), 0) rating_sum,
             COUNT(1)                rating_count
           FROM #{rate_table_name}
-          WHERE resource_type = ? and resource_id = ?
+          WHERE resource_type = ? and resource_id = ? and #{scope_query}
         ).squish
 
-        execute_sql [sql, resource.class.base_class.name, resource.id]
+        values = [sql, resource.class.base_class.name, resource.id]
+        values += [scopeable.class.base_class.name, scopeable.id] unless scopeable.nil?
+
+        execute_sql values
       end
 
-      def update_rating(resource)
-        record = find_or_initialize_by(resource: resource)
-        result = data(resource)
+      def update_rating(resource, scopeable)
+        record = find_or_initialize_by(resource: resource, scopeable: scopeable)
+        result = data(resource, scopeable)
 
         record.average  = result[:average]
         record.sum      = result[:sum]
@@ -78,19 +91,23 @@ module Rating
         Rate.find_by_sql(sql).first
       end
 
-      def how_many_resource_received_votes_sql?(distinct: false)
+      def how_many_resource_received_votes_sql?(distinct:, scopeable:)
         count = distinct ? 'COUNT(DISTINCT resource_id)' : 'COUNT(1)'
 
         %((
           SELECT #{count}
           FROM #{rate_table_name}
-          WHERE resource_type = :resource_type
+          WHERE resource_type = :resource_type and #{scope_type_query(scopeable)}
         ))
       end
 
       def rate_table_name
         @rate_table_name ||= Rate.table_name
       end
+
+      def scope_type_query(scopeable)
+        scopeable.nil? ? 'scopeable_type is NULL' : 'scopeable_type = :scopeable_type'
+      end
     end
   end
 end