rating 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a11655b90d44d485ffd1f791ddb1acf2438cdb4a
+  data.tar.gz: d18accbb4c21b0a63a3a771db0e0f32db007b289
+SHA512:
+  metadata.gz: 23142de88a5bde63875a119d0833c9321d6a351b01d9052a8c6f7a9c2c5aae4f86d6f0acea127f6c039779aca67b5bc7b63037b8ae520628d69e5946cf52393b
+  data.tar.gz: aa732a3d4c09ff0472a142c61a074590df24b8701d0898bdd39341f0622ffb80388d3198cdbc029614255d1cb4d558b4c86862fe38dcdf6f080773784ece8c25

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.1.0
+
+- First release.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Washington Botelho
+
+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,180 @@
+# Rating
+
+[![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.
+
+## JS Rating?
+
+This is **Raty**: https://github.com/wbotelhos/raty :star2:
+
+## Description
+
+Rating uses the know as "True Bayesian Estimate" inspired on [IMDb rating](http://www.imdb.com/help/show_leaf?votestopfaq) with the following formula:
+
+```
+(WR) = (v ÷ (v + m)) × R + (m ÷ (v + m)) × C
+```
+
+**IMDb Implementation:**
+
+`WR`: weighted rating
+
+`R`:  average for the movie (mean) = (Rating)
+
+`v`:  number of votes for the movie = (votes)
+
+`m`:  minimum votes required to be listed in the Top 250
+
+`C`:  the mean vote across the whole report
+
+**Rating Implementation:**
+
+`WR`: weighted rating
+
+`R`:  average for the resource (mean) = (Rating)
+
+`v`:  number of votes for the movie = (votes)
+
+`m`:  average of the number of votes
+
+`C`:  the mean vote across the whole report
+
+## Install
+
+Add the following code on your `Gemfile` and run `bundle install`:
+
+```ruby
+gem 'rating'
+```
+
+Run the following task to create a Rating migration:
+
+```bash
+rails g rating:install
+```
+
+Then execute the migrations to create the to create tables `rating_rates` and `rating_ratings`:
+
+```bash
+rake db:migrate
+```
+
+## Usage
+
+Just add the callback `rating` to your model:
+
+```ruby
+class User < ApplicationRecord
+  rating
+end
+```
+
+Now this model can vote or be voted.
+
+### rate
+
+You can vote on some resource:
+
+```ruby
+author   = User.last
+resource = Article.last
+
+author.rate(resource, 3)
+```
+
+### rating
+
+A voted resource exposes a cached data about it state:
+
+```ruby
+resource = Article.last
+
+resource.rating
+```
+
+It will return a `Rating` object that keeps:
+
+`average`: the normal mean of votes;
+
+`estimate`: the true Bayesian estimate mean value (you should use this over average);
+
+`sum`: the sum of votes for this resource;
+
+`total`: the total of votes for this resource.
+
+### rate_for
+
+You can retrieve the rate of some author gave to some resource:
+
+```ruby
+author   = User.last
+resource = Article.last
+
+author.rate_for resource
+```
+
+It will return a `Rate` object that keeps:
+
+`author`: the author of vote;
+
+`resource`: the resource that received the vote;
+
+`value`: the value of the vote.
+
+### rated?
+
+Maybe you want just to know if some author already rated some resource and receive `true` or `false`:
+
+```ruby
+author   = User.last
+resource = Article.last
+
+author.rated? resource
+```
+
+### rates
+
+You can retrieve all rates made by some author:
+
+```ruby
+author = User.last
+
+author.rates
+```
+
+It will return a collection of `Rate` object.
+
+### rated
+
+In the same way you can retrieve all rates that some author received:
+
+```ruby
+author = User.last
+
+author.rated
+```
+
+It will return a collection of `Rate` object.
+
+### order_by_rating
+
+You can list resource ordered by rating data:
+
+```ruby
+Article.order_by_rating
+```
+
+It will return a collection of resource ordered by `estimate desc` as default.
+The order column and direction can be changed:
+
+```ruby
+Article.order_by_rating :average, :asc
+```
+
+It will return a collection of resource ordered by `Rating` table data.
+
+## 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

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

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class CreateRatingTables < ActiveRecord::Migration[5.0]
+  def change
+    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.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,
+      unique: true
+
+    create_table :rating_ratings do |t|
+      t.decimal :average , default: 0, mull: false, precision: 17, scale: 14
+      t.decimal :estimate, default: 0, mull: false, precision: 17, scale: 14
+      t.integer :sum     , default: 0, mull: false
+      t.integer :total   , default: 0, mull: false
+
+      t.references :resource, index: true, null: false, polymorphic: true
+
+      t.timestamps null: false
+    end
+
+    add_index :rating_ratings, %i[resource_id resource_type], unique: true
+  end
+end

data/lib/rating.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Rating
+end
+
+require 'rating/models/rating/extension'
+require 'rating/models/rating/rate'
+require 'rating/models/rating/rating'
+
+ActiveRecord::Base.include Rating::Extension

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rating
+  module Extension
+    extend ActiveSupport::Concern
+
+    included do
+      def rate(resource, value, author: self)
+        Rate.create author: author, resource: resource, value: value
+      end
+
+      def rate_for(resource)
+        Rate.rate_for author: self, resource: resource
+      end
+
+      def rated?(resource)
+        !rate_for(resource).nil?
+      end
+    end
+
+    module ClassMethods
+      def rating
+        after_create { Rating.find_or_create_by resource: self }
+
+        has_one :rating,
+          as:         :resource,
+          class_name: '::Rating::Rating',
+          dependent:  :destroy
+
+        has_many :rates,
+          as:         :resource,
+          class_name: '::Rating::Rate',
+          dependent:  :destroy
+
+        has_many :rated,
+          as:         :author,
+          class_name: '::Rating::Rate',
+          dependent:  :destroy
+
+        scope :order_by_rating, ->(column = :estimate, direction = :desc) {
+          includes(:rating).order("#{Rating.table_name}.#{column} #{direction}")
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rating
+  class Rate < ActiveRecord::Base
+    self.table_name = 'rating_rates'
+
+    after_save :update_rating
+
+    belongs_to :author  , polymorphic: true
+    belongs_to :resource, 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]
+    }
+
+    def self.create(author:, resource:, value:)
+      record = find_or_initialize_by(author: author, resource: resource)
+
+      return record if record.persisted? && value == record.value
+
+      record.value = value
+      record.save
+
+      record
+    end
+
+    def self.rate_for(author:, resource:)
+      find_by author: author, resource: resource
+    end
+
+    private
+
+    def update_rating
+      ::Rating::Rating.update_rating resource
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Rating
+  class Rating < ActiveRecord::Base
+    self.table_name = 'rating_ratings'
+
+    belongs_to :resource, 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)
+
+        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
+        ).squish
+
+        execute_sql [sql, resource_type: resource.class.base_class.name]
+      end
+
+      def data(resource)
+        averager = averager_data(resource)
+        values   = values_data(resource)
+
+        {
+          average:  values.rating_avg,
+          estimate: estimate(averager, values),
+          sum:      values.rating_sum,
+          total:    values.rating_count
+        }
+      end
+
+      def values_data(resource)
+        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 = ?
+        ).squish
+
+        execute_sql [sql, resource.class.base_class.name, resource.id]
+      end
+
+      def update_rating(resource)
+        record = find_or_initialize_by(resource: resource)
+        result = data(resource)
+
+        record.average  = result[:average]
+        record.sum      = result[:sum]
+        record.total    = result[:total]
+        record.estimate = result[:estimate]
+
+        record.save
+      end
+
+      private
+
+      def estimate(averager, values)
+        resource_type_rating_avg = averager.rating_avg
+        count_avg                = averager.count_avg
+        resource_rating_avg      = values.rating_avg
+        resource_rating_count    = values.rating_count.to_f
+
+        (resource_rating_count / (resource_rating_count + count_avg)) * resource_rating_avg +
+          (count_avg           / (resource_rating_count + count_avg)) * resource_type_rating_avg
+      end
+
+      def execute_sql(sql)
+        Rate.find_by_sql(sql).first
+      end
+
+      def how_many_resource_received_votes_sql?(distinct: false)
+        count = distinct ? 'COUNT(DISTINCT resource_id)' : 'COUNT(1)'
+
+        %((
+          SELECT #{count}
+          FROM #{rate_table_name}
+          WHERE resource_type = :resource_type
+        ))
+      end
+
+      def rate_table_name
+        @rate_table_name ||= Rate.table_name
+      end
+    end
+  end
+end