mongoid_rating 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3619dc0eda67a2cfd21622ac78b7100d788be907
+  data.tar.gz: 3c000c1c31a4cefba53f948934fdcf568cb73326
+SHA512:
+  metadata.gz: edfbbd674d7a882ba979593ffb53d7e4d6d5a31636f0a268cc0c527ecd67edd14735b22802d346738063335e700387ba0e09d37223d0df296b85bfa49f784e8c
+  data.tar.gz: de68bfcc7cac056ae41782164acecbe61439359a08c0d4784b10a8f50c2bbac3743955cd59c0e66f75eb7aa8f1cb63121fb9bd4865e82c69e0bf328e621c88ec

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

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/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+mongoid_rating

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/.travis.yml

@@ -0,0 +1,22 @@
+services: mongodb
+
+notifications:
+  email: false
+
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+
+gemfile:
+  - Gemfile
+  - gemfiles/mongoid-3.0.gemfile
+  - gemfiles/mongoid-3.1.gemfile
+  - gemfiles/mongoid-4.0.gemfile
+
+matrix:
+  exclude:
+    - rvm: rbx-19mode
+      gemfile: gemfiles/mongoid-4.0.gemfile

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongoid_rating.gemspec
+gem "mongoid", github: "mongoid/mongoid"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2013 glebtv
+
+Copyright (c) 2010-2011 Vinova Pte Ltd
+Alex Nguyen - Author
+
+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,86 @@
+## Star rating for Mongoid 4 - MongoidRating
+
+[![Gem Version](https://badge.fury.io/rb/mongoid_rating.png)](http://badge.fury.io/rb/mongoid_rating)
+[![Dependency Status](https://gemnasium.com/rs-pro/mongoid_rating.png)](https://gemnasium.com/rs-pro/mongoid_rating)
+[![Build Status](https://travis-ci.org/rs-pro/mongoid_rating.png?branch=master)](https://travis-ci.org/rs-pro/mongoid_rating)
+[![Coverage Status](https://coveralls.io/repos/rs-pro/mongoid_rating/badge.png)](https://coveralls.io/r/rs-pro/mongoid_rating)
+
+## Currenty this gem supports only Mongoid 4
+
+## Features
+
+  - Multiple rating fields per model
+  - Float rating marks (users can give 4.5 stars)
+  - Accurate concurrent rating updates with db.eval
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mongoid_rating'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid_rating
+
+## Usage
+
+make model rateable:
+
+    class Post
+      include Mongoid::Document
+      rateable :rate
+    end
+    ps = Post.create()
+    user = User.create()
+
+rate and unrate:
+  
+    ps.rate 5, user
+    ps.unrate, user
+
+Get current rating
+
+    ps.rate
+    => 5.0 
+    ps.rate_by(user)
+    => 5 
+    
+Check if user rated:
+
+    ps.rate_by?(user)
+    => true 
+
+Scopes: 
+
+    Post.rate_in(2..5)
+    Post.rate_in(2..5).first
+    => #<Post rate_count: 1, rate_sum: 5.0, rate_average: 5.0> 
+    Post.rate_in(2..3).first
+    => nil 
+
+Posts rated by user:
+
+    Post.rate_by(user).first
+    => #<Post rate_count: 1, rate_sum: 5.0, rate_average: 5.0> 
+
+## Credits
+
+(c) 2013 glebtv, MIT license
+
+Partially based on
+(mongoid-rateable)[https://github.com/proton/mongoid_rateable]
+which is Copyright (c) 2011 Peter Savichev (proton), MIT license
+
+## 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,9 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new

data/gemfiles/mongoid-4.0.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "mongoid", github: "mongoid/mongoid", branch: "master"
+
+gemspec path: "../"

data/lib/mongoid_rating/model.rb

@@ -0,0 +1,168 @@
+module Mongoid
+  module Rating
+    module Model
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Make model rateable
+        # 
+        # @param [Hash] options a hash containings:
+        # 
+        # rateable :overall, range: -5..5
+        #
+        # Disable atomic eval (in case it's disabled on the database side)
+        # rateable :design, range: -5..5, average: false
+        # 
+        # Disable average completely
+        # rateable :quality, range: -5..5, average: true
+        def rateable(field, options = {})
+          options = {
+            range: 1..5,
+            rerate: true,
+            eval: true,
+            counters: true,
+            float: true
+          }.merge(options)
+          field = field.to_sym
+          sfield = field.inspect
+
+          # total rates count
+          field "#{field}_count", type: Integer, default: 0
+
+          # rates data
+          embeds_many "#{field}_data", as: :rateable, class_name: 'Mongoid::Rating::Rate', counter_cache: true
+
+          # sum of all rates to calculate average
+          field "#{field}_sum".to_sym, type: options[:float] ? Float : Integer
+
+          # average rate value
+          avg = "#{field}_average".to_sym
+          field avg, type: Float
+          savg = avg.inspect
+
+          class_eval <<-RUBY, __FILE__, __LINE__+1
+            scope :#{field}_by, ->(rater) {
+              where("#{field}_data.rater_id" => rater.id, "#{field}_data.rater_type" => rater.class.to_s)
+            }
+            scope :#{field}_in, ->(range) {
+              where(#{savg}.gte => range.begin, #{savg}.lte => range.end)
+            }
+            scope :highest_#{field}, -> {
+              where(#{savg}.ne => nil).order_by([#{savg}, :desc])
+            }
+
+            def #{field}!(value, rater)
+              value = value.to_i unless #{options[:float]}
+              unless (#{options[:range]}).include?(value)
+                raise "bad vote value"
+              end
+              raise "can't rate" unless can_#{field}?(rater)
+              if #{options[:eval]}
+                #{field}_data.where(rater_id: rater.id).destroy_all
+                #{field}_data.create!(rater: rater, value: value)
+                collection.database.session.cluster.with_primary do
+                  doc = collection.database.command({
+                    eval: 'function(id) { 
+                      var oid = ObjectId(id);
+                      var doc = db.' + collection.name + '.findOne( { _id : oid } );
+                      if (doc) {
+                        doc.#{field}_count = 0
+                        doc.#{field}_sum = 0;
+                        doc.#{field}_data.forEach(function(fd) {
+                          doc.#{field}_sum += fd.value;
+                          doc.#{field}_count += 1;
+                        })
+                        doc.#{field}_average = doc.#{field}_sum /doc.#{field}_count;
+                        db.' + collection.name + '.save(doc);
+                        return doc;
+                      } else {
+                        return false;
+                      }
+                    }',
+                    args: [ id.to_s ]
+                  })
+                  self.#{field}_count = doc[:retval]["#{field}_count"]
+                  self.#{field}_sum = doc[:retval]["#{field}_sum"]
+                  self.#{field}_average = doc[:retval]["#{field}_average"]
+                  remove_change(:#{field}_count)
+                  remove_change(:#{field}_sum)
+                  remove_change(:#{field}_average)
+                end
+              else
+                un#{field}!(rater)
+                atomically do
+                  inc("#{field}_count" => 1, "#{field}_sum" => value)
+                  #{field}_data.create!(rater: rater, value: value)
+                  set("#{field}_average" => calc_#{field}_avg)
+                end
+              end
+            end
+            def calc_#{field}_avg
+              if #{field}_count < 1
+                nil
+              else
+                #{field}_sum.to_f / #{field}_count.to_f
+              end
+            end
+            def un#{field}!(rater)
+              r = #{field}_data.where(rater_id: rater.id).first
+              if r.nil?
+                # not rated before
+              else
+                atomically do
+                  inc("#{field}_count" => -1, "#{field}_sum" => -r.value)
+                  set("#{field}_average" => calc_#{field}_avg)
+                  r.destroy
+                end
+              end
+            end
+            alias_method :un#{field}, :un#{field}!
+            
+            def did_#{field}?(rater)
+              !raw_#{field}_by(rater).nil?
+            end
+
+            def can_#{field}?(rater)
+              if #{options[:rerate]}
+                true
+              else
+                !did_#{field}?(rater)
+              end
+            end
+
+            def raw_#{field}_by(rater)
+              #{field}_data.select do |rate|
+                rate[:rater_id] == rater.id && rate[:rater_type] == rater.class.name
+              end.first
+            end
+
+            def #{field}(value=nil, rater=nil)
+              if rater.nil? && value.nil?
+                #{field}_count.nil? ? nil : #{field}_average
+              else
+                #{field}!(value, rater)
+              end
+            end
+
+            def #{field}_values
+              #{field}_data.map(&:value)
+            end
+
+            def #{field}_by(rater)
+              rate = raw_#{field}_by(rater)
+              if rate.nil?
+                nil
+              else
+                rate.value
+              end
+            end
+            def #{field}_by?(rater)
+              !#{field}_by(rater).nil?
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid_rating/rate.rb

@@ -0,0 +1,13 @@
+module Mongoid::Rating
+  class Rate
+    include Mongoid::Document
+    include Mongoid::Timestamps::Short
+    
+    embedded_in :rateable, polymorphic: true
+    belongs_to :rater, polymorphic: true, inverse_of: nil
+
+    # rate can be integer or float so we don't force class here
+    field :value
+  end
+end
+

data/lib/mongoid_rating/version.rb

@@ -0,0 +1,3 @@
+module MongoidRating
+  VERSION = "0.0.2"
+end

data/lib/mongoid_rating.rb

@@ -0,0 +1,6 @@
+require "mongoid_rating/version"
+require 'mongoid_rating/rate'
+require 'mongoid_rating/model'
+
+Mongoid::Document.send :include, Mongoid::Rating::Model
+

data/mongoid_rating.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid_rating/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongoid_rating"
+  spec.version       = MongoidRating::VERSION
+  spec.authors       = ["glebtv"]
+  spec.email         = ["glebtv@gmail.com"]
+  spec.description   = %q{Star rating for Mongoid}
+  spec.summary       = %q{Star rating for Mongoid}
+  spec.homepage      = "https://github.com/rs-pro/mongoid_rating"
+  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_dependency "mongoid", [">= 4.0", "< 5.0"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "coveralls"
+end

data/spec/article_spec.rb

@@ -0,0 +1,259 @@
+require "spec_helper"
+
+describe Article do
+
+  before(:each) do
+    @bob = User.create :name => "Bob"
+    @sally = User.create :name => "Sally"
+    @alice = User.create :name => "Alice"
+    @article = Article.create :name => "Article"
+    @article1 = Article.create :name => "Article 1"
+    @article2 = Article.create :name => "Article 2"
+  end
+
+  subject { @article }
+  it { should respond_to :overall }
+  it { should respond_to :overall! }
+  it { should respond_to :unoverall! }
+  it { should respond_to :did_overall? }
+  it { should respond_to :overall_average }
+  it { should respond_to :overall_data }
+  it { should respond_to :overall_by }
+
+  describe "#overall_values" do
+    it "should be an array with overall values" do
+      @article.overall_values.should be_an_instance_of Array
+      @article.overall! 1, @bob
+      @article.overall_values.should eq [1]
+    end
+  end
+
+  context "when overall" do
+    before (:each) do
+      @article.overall! 1, @bob
+    end
+
+    describe "#overall" do
+      it "should track #overall properly" do
+        @article.overall! 1, @sally
+        @article.overall_count.should eql 2
+        @article.overall.should eql 1.0
+      end
+
+      it "should not mark fields as dirty" do
+        @article.overall_count_changed?.should be_false
+        @article.overall_sum_changed?.should be_false
+        @article.overall_average_changed?.should be_false
+      end
+
+      it "should limit #overalls by user properly" do
+        @article.overall! 5, @bob
+        @article.overall.should eql 5.0
+      end
+
+      context "when overall_value in rating range" do
+        it { expect { @article.overall 1, @sally }.not_to raise_error }
+      end
+
+      context "when overall_value not in rating range" do
+        it { expect { @article.overall 17, @sally }.to raise_error() }
+        it { expect { @article.overall -17, @sally }.to raise_error() }
+      end
+
+      describe "when using positive values" do
+        let(:num) { rand(1..5) }
+        let(:exp) { ((num + 1) / 2.0) - 1 }
+        it { expect { @article.overall num, @sally }.to change { @article.overall }.by(exp) }
+      end
+
+      describe "when using negative values" do
+        let(:num) { -rand(1..5) }
+        let(:exp) { ((num + 1) / 2.0) - 1 }
+        it { expect { @article.overall num, @sally }.to change { @article.overall }.by(exp) }
+      end
+    end
+
+    describe "#overall_by?" do
+      describe "for Bob" do
+        specify { @article.overall_by?(@bob).should be_true }
+      end
+      describe "for Bob" do
+        specify { @article1.overall_by?(@bob).should be_false }
+        specify { @article.overall_by?(@alice).should be_false }
+      end
+
+      describe "when overall by someone else" do
+        before do
+          @article.overall 1, @alice
+        end
+
+        describe "for Alice" do
+          specify { @article.overall_by?(@alice).should be_true }
+        end
+      end
+
+      describe "when not overall by someone else" do
+        describe "for Sally" do
+          specify { @article.overall_by?(@sally).should be_false }
+        end
+      end
+    end
+
+    describe "#unoverall" do
+      before { @article.unoverall @bob }
+
+      it "should have null #overall_count" do
+        @article.overall_count.should eql 0
+      end
+
+      it "should have null #overall" do
+        @article.overall.should be_nil
+      end
+
+      it "#overall_by?(@bob) should be false after unoverall" do
+        @article.overall_by?(@bob).should be_false
+      end
+    end
+
+    describe "#overall_count" do
+      it "should know how many overalls have been cast" do
+        @article.overall 1, @sally
+        @article.overall_count.should eql 2
+      end
+    end
+
+    describe "#rating" do
+      it "should calculate the average overall" do
+        @article.overall 4, @sally
+        @article.overall.should eq 2.5
+      end
+
+      it "should calculate the average overall if the result is zero" do
+        @article.overall -1, @sally
+        @article.overall.should eq 0.0
+      end
+    end
+  end
+
+  context "when not overall" do
+    describe "#overalls" do
+      specify { @article.overall_count.should eql 0 }
+    end
+
+    describe "#rating" do
+      specify { @article.overall.should be_nil }
+    end
+
+    describe "#unoverall" do
+      before do
+        @article.unoverall @sally
+      end
+
+      it "should have null #overall_count" do
+        @article.overall_count.should eql 0
+      end
+
+      it "should have null #overalls" do
+        @article.overall.should be_nil
+      end
+    end
+  end
+
+  context "when saving the collection" do
+    before (:each) do
+      @article.overall 3, @bob
+      @article.overall -5, @sally
+      @article.save
+      @f_article = Article.where(:name => "Article").first
+    end
+
+    it "disallows incorrect rates" do
+      expect { @article.overall 8, @bob }.to raise_error
+      expect { @article.overall -10, @sally }.to raise_error
+    end
+
+    describe "#overall_by?" do
+      describe "for Bob" do
+        specify { @f_article.overall_by?(@bob).should be_true }
+        specify { @f_article.overall_by(@bob).should eq 3 }
+      end
+
+      describe "for Sally" do
+        specify { @f_article.overall_by?(@sally).should be_true }
+        specify { @f_article.overall_by(@sally).should eq -5 }
+      end
+
+      describe "for Alice" do
+        specify { @f_article.overall_by?(@alice).should be_false}
+        specify { @f_article.overall_by(@alice).should be_nil }
+      end
+    end
+
+    describe "#overall" do
+      specify { @f_article.overall.should eql -1.0 }
+    end
+
+    describe "#overall_count" do
+      specify { @f_article.overall_count.should eql 2 }
+    end
+  end
+
+  describe "#scopes" do
+    before (:each) do
+      @article.delete
+      @article1 = Article.create(:name => "Article 1")
+      @article2 = Article.create(:name => "Article 2")
+      @article3 = Article.create(:name => "Article 3")
+      @article4 = Article.create(:name => "Article 4")
+      @article5 = Article.create(:name => "Article 5")
+      @article1.overall 5, @sally
+      @article1.overall 3, @bob
+      @article4.overall 1, @sally
+    end
+
+    describe "#overall_by" do
+      it "should return proper count of articles overall by Bob" do
+        Article.overall_by(@bob).size.should eql 1
+      end
+
+      it "should return proper count of articles overall by Sally" do
+        Article.overall_by(@sally).size.should eql 2
+      end
+    end
+
+    describe "#overall_in" do
+      before (:each) do
+        @article1.overall 4, @alice
+        @article2.overall 2, @alice
+        @article3.overall 5, @alice
+        @article4.overall 2, @alice
+      end
+
+      it "should return proper count of articles with rating 4..5" do
+        Article.overall_in(4..5).to_a.length.should eql 2
+      end
+
+      it "should return proper count of articles with rating 0..2" do
+        Article.overall_in(0..2).to_a.length.should eql 2
+      end
+
+      it "should return proper count of articles with rating 0..5" do
+        Article.overall_in(0..5).to_a.length.should eql 4
+      end
+    end
+
+    describe "#highest_overall" do
+      it "should return proper count of articles" do
+        Article.highest_overall.limit(1).count(true).should eq 1
+      end
+
+      it "should return proper count of articles" do
+        Article.highest_overall.limit(10).count(true).should eq 2
+      end
+
+      it "should return proper document" do
+        Article.highest_overall.limit(1).first.name.should eql "Article 1"
+      end
+    end
+  end
+end