activerecord-reputation-system 1.2.1 → 1.3.0

data/README.md

@@ -1,4 +1,4 @@
-## Active Record Reputation System  [![Build Status](https://secure.travis-ci.org/twitter/activerecord-reputation-system.png)](http://travis-ci.org/twitter/activerecord-reputation-system)
+## Active Record Reputation System  [![Build Status](https://secure.travis-ci.org/twitter/activerecord-reputation-system.png)](http://travis-ci.org/twitter/activerecord-reputation-system) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/twitter/activerecord-reputation-system)
 
 The Active Record Reputation System helps you discover more about your application and make better decisions. The Reputation System gem makes it easy to integrate reputation systems into Rails applications, decouple the system from the main application and provide guidelines for good design of reputation systems.
 
@@ -165,12 +165,12 @@ reputations_activated?(reputation_name)
 # Includes the specified reputation value for the given name via a normal Active Record find query.
 ActiveRecord::Base.find_with_reputation(reputation_name, find_scope, options)
 # For example:
-ActiveRecord::Base.find_with_reputation(:maturity, :all, {:select => "id", :conditions => ["maturity > ?", 3], :order => "maturity"})
+User.find_with_reputation(:karma, :all, {:select => "id", :conditions => ["karma > ?", 3], :order => "karma"})
 
 # Includes the specified normalized reputation value for the given name via a normal Active Record find query.
 ActiveRecord::Base.find_with_normalized_reputation(reputation_name, find_options)
 # For example:
-ActiveRecord::Base.find_with_normalized_reputation(:maturity, :all, {:select => "id", :conditions => ["maturity > ?", 3], :order => "maturity"})
+User.find_with_normalized_reputation(:karma, :all, {:select => "id", :conditions => ["karma > ?", 0.5], :order => "karma"})
 
 # Includes the specified reputation value for the given name via a normal Active Record count query.
 ActiveRecord::Base.count_with_reputation(reputation_name, find_options)
@@ -179,6 +179,15 @@ ActiveRecord::Base.count_with_reputation(reputation_name, find_options)
 ActiveRecord::Base.find_with_reputation_sql(reputation_name, find_options)
 ```
 
+## Querying for Evaluated ActiveRecord
+```ruby
+# Returns all active record instances evaluated by a given source for a given reputation name.
+ActiveRecord::Base.evaluated_by(reputation_name, source)
+# For example:
+Question.evaluated_by(:votes, @user)
+#
+```
+
 ## Advanced Topics
 ### Scope
 Reputations can have different scopes to provide additional context.
@@ -213,6 +222,10 @@ To execute an Active Record query using a scoped reputation, try this:
 ```ruby
 ActiveRecord::Base.find_with_reputation(:reputation_name, :scope, :find_options)
 ```
+To find active records evaluated by a given source for a scoped reputation, try this:
+```ruby
+ActiveRecord::Base.evaluated_by(:reputation_name, source, :scope)
+```
 There are a few more helper methods available for scopes:
 ```ruby
 # Allows you to add a scope dynamically.
@@ -268,6 +281,10 @@ For more information on semantic versioning, please visit http://semver.org/.
 * Katsuya Noguchi: http://github.com/katsuyan
 * Inspired by ["Building Web Reputation Systems" by Randy Farmer and Bryce Glass](http://shop.oreilly.com/product/9780596159801.do)
 
+## Related Links
+
+* RailsCasts: http://railscasts.com/episodes/364-active-record-reputation-system
+
 ## License
 
 Copyright 2012 Twitter, Inc.

data/lib/models/rs_reputation.rb

@@ -65,9 +65,10 @@ class RSReputation < ActiveRecord::Base
     else
       raise ArgumentError, "#{process} process is not supported yet"
     end
-    rep.save!
+    save_succeeded = rep.save
     RSReputationMessage.add_reputation_message_if_not_exist(source, rep)
     propagate_updated_reputation_value(rep, valueBeforeUpdate) if rep.target
+    save_succeeded
   end
 
   def self.update_reputation_value_with_updated_source(rep, source, oldValue, weight, process)
@@ -85,8 +86,9 @@ class RSReputation < ActiveRecord::Base
     else
       raise ArgumentError, "#{process} process is not supported yet"
     end
-    rep.save!
+    save_succeeded = rep.save
     propagate_updated_reputation_value(rep, valueBeforeUpdate) if rep.target
+    save_succeeded
   end
 
   def normalized_value
@@ -123,29 +125,34 @@ class RSReputation < ActiveRecord::Base
 
     # Propagates updated reputation value to the reputations whose source is the updated reputation.
     def self.propagate_updated_reputation_value(sender, oldValue)
-      sender_name = sender.reputation_name.to_sym
-      receiver_defs = ReputationSystem::Network.get_reputation_def(sender.target.class.name, sender_name)[:source_of]
-      if receiver_defs
-        receiver_defs.each do |rd|
-          receiver_targets = sender.target.get_attributes_of(rd)
-          receiver_targets.each do |rt|
-            scope = sender.target.evaluate_reputation_scope(rd[:scope])
-            srn = ReputationSystem::Network.get_scoped_reputation_name(rt.class.name, rd[:reputation], scope)
-            process = ReputationSystem::Network.get_reputation_def(rt.class.name, srn)[:aggregated_by]
-            rep = find_by_reputation_name_and_target(srn, rt)
-            if rep
-              weight = ReputationSystem::Network.get_weight_of_source_from_reputation_name_of_target(rt, sender_name, srn)
-              unless oldValue
-                update_reputation_value_with_new_source(rep, sender, weight, process)
-              else
-                update_reputation_value_with_updated_source(rep, sender, oldValue, weight, process)
-              end
-            # If r is new then value update will be done when it is initialized.
-            else
-              create_reputation(srn, rt, process)
-            end
-          end
+      receiver_defs = ReputationSystem::Network.get_reputation_def(sender.target.class.name, sender.reputation_name)[:source_of]
+      receiver_defs.each do |rd|
+        targets = sender.target.get_attributes_of(rd)
+        targets.each do |target|
+          scope = sender.target.evaluate_reputation_scope(rd[:scope])
+          send_reputation_message_to_receiver(rd[:reputation], sender, target, scope, oldValue)
         end
+      end if receiver_defs
+    end
+
+    def self.send_reputation_message_to_receiver(reputation_name, sender, target, scope, oldValue)
+      srn = ReputationSystem::Network.get_scoped_reputation_name(target.class.name, reputation_name, scope)
+      process = ReputationSystem::Network.get_reputation_def(target.class.name, srn)[:aggregated_by]
+      receiver = find_by_reputation_name_and_target(srn, target)
+      if receiver
+        weight = ReputationSystem::Network.get_weight_of_source_from_reputation_name_of_target(target, sender.reputation_name, srn)
+        update_reputation_value(receiver, sender, weight, process, oldValue)
+      # If r is new then value update will be done when it is initialized.
+      else
+        create_reputation(srn, target, process)
+      end
+    end
+
+    def self.update_reputation_value(receiver, sender, weight, process, oldValue)
+      unless oldValue
+        update_reputation_value_with_new_source(receiver, sender, weight, process)
+      else
+        update_reputation_value_with_updated_source(receiver, sender, oldValue, weight, process)
       end
     end
 

data/lib/reputation_system.rb

@@ -16,7 +16,6 @@
 
 require 'reputation_system/base'
 require 'reputation_system/query'
-require 'reputation_system/normalization'
 require 'reputation_system/evaluation'
 require 'reputation_system/network'
 require 'reputation_system/reputation'
@@ -25,4 +24,4 @@ require 'models/rs_evaluation'
 require 'models/rs_reputation'
 require 'models/rs_reputation_message'
 
-ActiveRecord::Base.send(:include, ReputationSystem::Base)
+ActiveRecord::Base.send(:include, ReputationSystem::Base)

data/lib/reputation_system/base.rb

@@ -51,7 +51,6 @@ module ReputationSystem
         unless ancestors.include?(ReputationSystem::Reputation)
           has_many :reputations, :as => :target, :class_name => "RSReputation", :dependent => :destroy
           include ReputationSystem::Query
-          include ReputationSystem::Normalization
           include ReputationSystem::Reputation
           include ReputationSystem::Scope
         end

data/lib/reputation_system/evaluation.rb

@@ -16,8 +16,24 @@
 
 module ReputationSystem
   module Evaluation
+    module ClassMethods
+      def evaluated_by(reputation_name, source, *args)
+        scope = args.first
+        srn = ReputationSystem::Network.get_scoped_reputation_name(self.name, reputation_name, scope)
+        source_type = source.class.name
+        options = {}
+        options[:select] ||= sanitize_sql_array(["%s.*", self.table_name])
+        options[:joins] = sanitize_sql_array(["JOIN rs_evaluations ON %s.id = rs_evaluations.target_id AND rs_evaluations.target_type = ? AND rs_evaluations.reputation_name = ? AND rs_evaluations.source_id = ? AND rs_evaluations.source_type = ?", self.name, srn.to_s, source.id, source_type])
+        options[:joins] = sanitize_sql_array([options[:joins], self.table_name])
+        find(:all, options) 
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
     def add_evaluation(reputation_name, value, source, *args)
-      raise ArgumentError, "#{reputation_name.to_s} is not defined for #{self.class.name}" unless ReputationSystem::Network.has_reputation_for?(self.class.name, reputation_name)
       scope = args.first
       srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
       process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
@@ -27,63 +43,32 @@ module ReputationSystem
     end
 
     def update_evaluation(reputation_name, value, source, *args)
-      raise ArgumentError, "#{reputation_name.to_s} is not defined for #{self.class.name}" unless ReputationSystem::Network.has_reputation_for?(self.class.name, reputation_name)
-      scope = args.first
-      srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
-      evaluation = RSEvaluation.find_by_reputation_name_and_source_and_target(srn, source, self)
-      if evaluation.nil?
-        raise ArgumentError, "Given instance of #{source.class.name} has not evaluated #{reputation_name} of the instance of #{self.class.name} yet."
-      else
-        oldValue = evaluation.value
-        evaluation.value = value
-        evaluation.save!
-        process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
-        rep = RSReputation.find_by_reputation_name_and_target(srn, self)
-        RSReputation.update_reputation_value_with_updated_source(rep, evaluation, oldValue, 1, process)
-      end
+      srn, evaluation = find_srn_and_evaluation!(reputation_name, source, args.first)
+      oldValue = evaluation.value
+      evaluation.value = value
+      evaluation.save!
+      process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
+      rep = RSReputation.find_by_reputation_name_and_target(srn, self)
+      RSReputation.update_reputation_value_with_updated_source(rep, evaluation, oldValue, 1, process)
     end
 
     def add_or_update_evaluation(reputation_name, value, source, *args)
-      scope = args.first
-      srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
-      evaluation = RSEvaluation.find_by_reputation_name_and_source_and_target(srn, source, self)
-      if evaluation.nil?
-        self.add_evaluation(reputation_name, value, source, scope)
+      srn, evaluation = find_srn_and_evaluation(reputation_name, source, args.first)
+      if RSEvaluation.exists? :reputation_name => srn, :source_id => source.id, :source_type => source.class.name, :target_id => self.id, :target_type => self.class.name
+        self.update_evaluation(reputation_name, value, source, *args)
       else
-        self.update_evaluation(reputation_name, value, source, scope)
+        self.add_evaluation(reputation_name, value, source, *args)
       end
     end
 
     def delete_evaluation(reputation_name, source, *args)
-      raise ArgumentError, "#{reputation_name.to_s} is not defined for #{self.class.name}" unless ReputationSystem::Network.has_reputation_for?(self.class.name, reputation_name)
-      scope = args.first
-      srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
-      evaluation = RSEvaluation.find_by_reputation_name_and_source_and_target(srn, source, self)
-      unless evaluation.nil?
-        process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
-        oldValue = evaluation.value
-        evaluation.value = process == :product ? 1 : 0
-        rep = RSReputation.find_by_reputation_name_and_target(srn, self)
-        RSReputation.update_reputation_value_with_updated_source(rep, evaluation, oldValue, 1, process)
-        evaluation.destroy
-      end
+      srn, evaluation = find_srn_and_evaluation(reputation_name, source, args.first)
+      delete_evaluation_without_validation(srn, evaluation) if evaluation
     end
 
     def delete_evaluation!(reputation_name, source, *args)
-      raise ArgumentError, "#{reputation_name.to_s} is not defined for #{self.class.name}" unless ReputationSystem::Network.has_reputation_for?(self.class.name, reputation_name)
-      scope = args.first
-      srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
-      evaluation = RSEvaluation.find_by_reputation_name_and_source_and_target(srn, source, self)
-      if evaluation.nil?
-        raise ArgumentError, "Given instance of #{source.class.name} has not evaluated #{reputation_name} of the instance of #{self.class.name} yet."
-      else
-        process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
-        oldValue = evaluation.value
-        evaluation.value = process == :product ? 1 : 0
-        rep = RSReputation.find_by_reputation_name_and_target(srn, self)
-        RSReputation.update_reputation_value_with_updated_source(rep, evaluation, oldValue, 1, process)
-        evaluation.destroy
-      end
+      srn, evaluation = find_srn_and_evaluation!(reputation_name, source, args.first)
+      delete_evaluation_without_validation(srn, evaluation)
     end
 
     def increase_evaluation(reputation_name, value, source, *args)
@@ -95,6 +80,33 @@ module ReputationSystem
     end
 
     protected
+      def find_srn_and_evaluation(reputation_name, source, scope)
+        srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
+        evaluation = RSEvaluation.find_by_reputation_name_and_source_and_target(srn, source, self)
+        return srn, evaluation
+      end
+
+      def find_srn_and_evaluation!(reputation_name, source, scope)
+        srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
+        evaluation = find_evaluation!(reputation_name, srn, source)
+        return srn, evaluation
+      end
+
+      def find_evaluation!(reputation_name, srn, source)
+        evaluation = RSEvaluation.find_by_reputation_name_and_source_and_target(srn, source, self)
+        raise ArgumentError, "Given instance of #{source.class.name} has not evaluated #{reputation_name} of the instance of #{self.class.name} yet." unless evaluation
+        evaluation
+      end
+
+      def delete_evaluation_without_validation(srn, evaluation)
+        process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
+        oldValue = evaluation.value
+        evaluation.value = process == :product ? 1 : 0
+        rep = RSReputation.find_by_reputation_name_and_target(srn, self)
+        RSReputation.update_reputation_value_with_updated_source(rep, evaluation, oldValue, 1, process)
+        evaluation.destroy
+      end
+
       def change_evaluation_value_by(reputation_name, value, source, *args)
         scope = args.first
         srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)

data/lib/reputation_system/network.rb

@@ -82,6 +82,7 @@ module ReputationSystem
       end
 
       def get_scoped_reputation_name(class_name, reputation_name, scope)
+        raise ArgumentError, "#{reputation_name.to_s} is not defined for #{class_name}" unless has_reputation_for?(class_name, reputation_name)
         scope = scope.to_sym if scope
         validate_scope_necessity(class_name, reputation_name, scope)
         validate_scope_existence(class_name, reputation_name, scope)
@@ -92,13 +93,12 @@ module ReputationSystem
         source = get_reputation_def(target.class.name, reputation_name)[:source]
         if source.is_a?(Array)
           source.each do |s|
-            scope = target.evaluate_reputation_scope(s[:scope]) if s[:scope]
-            of = target.get_attributes_of(s)
-            srn = get_scoped_reputation_name((of.is_a?(Array) ? of[0] : of ).class.name, s[:reputation], scope)
-            source = s if srn.to_sym == source_name.to_sym
+            srn = get_scoped_reputation_name_from_source_def_and_target(s, target)
+            return s[:weight] if srn.to_sym == source_name.to_sym
           end
+        else
+          source[:weight]
         end
-        source[:weight]
       end
 
       protected
@@ -113,34 +113,44 @@ module ReputationSystem
 
         def create_scoped_reputation_def(class_name, reputation_name, scope, options)
           raise ArgumentError, "#{reputation_name} does not have scope." unless has_scopes?(class_name, reputation_name)
-          scope_options = {}
+          scope_options = options.reject { |k, v| ![:source, :aggregated_by].include? k }
           reputation_def = get_reputation_def(class_name, reputation_name)
-          if is_primary_reputation?(class_name, reputation_name)
-            scope_options[:source] = options[:source]
-          else
+          unless is_primary_reputation?(class_name, reputation_name)
             scope_options[:source] = []
-            reputation_def[:source].each do |s|
-              rep = {}
-              rep[:reputation] = s[:reputation]
-              # Passing "this" is not pretty but in some case "instance_exec" method
-              # does not give right context for some reason.
-              # This could be ruby bug. Needs further investigation.
-              rep[:of] = lambda { |this| instance_exec(this, scope.to_s, &s[:of]) } if s[:of].is_a? Proc
-              scope_options[:source].push rep
-            end
+            reputation_def[:source].each { |sd| scope_options[:source].push create_source_reputation_def(sd, scope) }
           end
-          source_of = reputation_def[:source_of]
-          source_of.each do |so|
-            if so[:defined_for_scope].nil? || (so[:defined_for_scope] && so[:defined_for_scope].include?(scope.to_sym))
+          (reputation_def[:source_of] || []).each do |so|
+            if source_of_defined_for_scope?(so, scope)
               scope_options[:source_of] ||= []
               scope_options[:source_of].push so
             end
-          end if source_of
-          scope_options[:aggregated_by] = options[:aggregated_by]
+          end
           srn = get_scoped_reputation_name(class_name, reputation_name, scope)
           network[class_name.to_sym][srn.to_sym] = scope_options
         end
 
+        def create_source_reputation_def(source_def, scope)
+          rep = {}
+          rep[:reputation] = source_def[:reputation]
+          # Passing "this" is not pretty but in some case "instance_exec" method
+          # does not give right context for some reason.
+          # This could be ruby bug. Needs further investigation.
+          rep[:of] = lambda { |this| instance_exec(this, scope.to_s, &source_def[:of]) } if source_def[:of].is_a? Proc
+          rep
+        end
+
+        def get_scoped_reputation_name_from_source_def_and_target(source_def, target)
+          scope = target.evaluate_reputation_scope(source_def[:scope]) if source_def[:scope]
+          of = target.get_attributes_of(source_def)
+          class_name = (of.is_a?(Array) ? of[0] : of).class.name
+          get_scoped_reputation_name(class_name, source_def[:reputation], scope)
+        end
+
+        def source_of_defined_for_scope?(source_of_def, scope)
+          defined_for_scope = source_of_def[:defined_for_scope]
+          defined_for_scope.nil? || (defined_for_scope && defined_for_scope.include?(scope.to_sym))
+        end
+
         def construct_scoped_reputation_options(class_name, reputation_name, options)
           scopes = get_reputation_def(class_name, reputation_name)[:scopes]
           scopes.each do |scope|
@@ -149,20 +159,36 @@ module ReputationSystem
         end
 
         def derive_source_of_from_source(class_name, reputation_name, source, src_class_name)
-          if source[:of] && source[:of].is_a?(Symbol) && source[:of] != :self
-            klass = src_class_name.to_s.constantize
-            of_value = class_name.tableize
-            of_value = of_value.chomp('s') unless klass.instance_methods.include?(of_value.to_s) || klass.instance_methods.include?(of_value.to_sym)
-          else
-            of_value = "self"
-          end
+          of_value = derive_of_value(class_name, source[:of], src_class_name)
           reputation_def = get_reputation_def(src_class_name, source[:reputation])
           reputation_def[:source_of] ||= []
-          unless reputation_def[:source_of].any? {|elem| elem[:reputation] == reputation_name.to_sym}
+          unless source_of_include_reputation?(reputation_def[:source_of], reputation_name)
             reputation_def[:source_of] << {:reputation => reputation_name.to_sym, :of => of_value.to_sym}
           end
         end
 
+        def derive_of_value(class_name, source_of, src_class_name)
+          if not_source_of_self?(source_of)
+            attr = class_name.tableize
+            class_has_attribute?(src_class_name, attr) ? attr :  attr.chomp('s')
+          else
+            "self"
+          end
+        end
+
+        def not_source_of_self?(source_of)
+          source_of && source_of.is_a?(Symbol) && source_of != :self
+        end
+
+        def class_has_attribute?(class_name, attribute)
+          klass = class_name.to_s.constantize
+          klass.instance_methods.include?(attribute.to_s) || klass.instance_methods.include?(attribute.to_sym)
+        end
+
+        def source_of_include_reputation?(source_of, reputation_name)
+          source_of.map { |rep| rep[:reputation] }.include?(reputation_name.to_sym)
+        end
+
         def derive_source_of_from_source_later(class_name, reputation_name, source, src_class_name)
           reputation = source[:reputation].to_sym
           src_class_name = src_class_name.to_sym

data/lib/reputation_system/reputation.rb

@@ -17,17 +17,32 @@
 module ReputationSystem
   module Reputation
     def reputation_value_for(reputation_name, *args)
-      scope = args.first
-      if !self.class.has_reputation_for?(reputation_name)
-        raise ArgumentError, "#{reputation_name} is not valid"
-      else
-        reputation_name = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
-        process = ReputationSystem::Network.get_reputation_def(self.class.name, reputation_name)[:aggregated_by]
-        reputation = RSReputation.find_or_create_reputation(reputation_name, self, process)
-        reputation.value
+      find_reputation(reputation_name, args.first).value
+    end
+
+    def normalized_reputation_value_for(reputation_name, *args)
+      find_reputation(reputation_name, args.first).normalized_value
+    end
+
+    def activate_all_reputations
+      RSReputation.find(:all, :conditions => {:target_id => self.id, :target_type => self.class.name, :active => false}).each do |r|
+        r.active = true
+        r.save!
+      end
+    end
+
+    def deactivate_all_reputations
+      RSReputation.find(:all, :conditions => {:target_id => self.id, :target_type => self.class.name, :active => true}).each do |r|
+        r.active = false
+        r.save!
       end
     end
 
+    def reputations_activated?(reputation_name)
+      r = RSReputation.find(:first, :conditions => {:reputation_name => reputation_name.to_s, :target_id => self.id, :target_type => self.class.name})
+      r ? r.active : false
+    end
+
     def rank_for(reputation_name, *args)
       scope = args.first
       my_value = self.reputation_value_for(reputation_name, scope)
@@ -35,5 +50,13 @@ module ReputationSystem
         :conditions => ["rs_reputations.value > ?", my_value]
       ) + 1
     end
+
+    protected
+      def find_reputation(reputation_name, scope)
+        raise ArgumentError, "#{reputation_name} is not valid" if !self.class.has_reputation_for?(reputation_name)
+        srn = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
+        process = ReputationSystem::Network.get_reputation_def(self.class.name, srn)[:aggregated_by]
+        RSReputation.find_or_create_reputation(srn, self, process)
+      end
   end
-end
+end

data/lib/reputation_system/version.rb

@@ -15,5 +15,5 @@
 ##
 
 module ReputationSystem
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

data/spec/reputation_system/evaluation_spec.rb

@@ -26,9 +26,55 @@ describe ActiveRecord::Base do
   end
 
   context "Primary Reputation" do
+    describe "#evaluated_by" do
+      it "should return an empty array if it is not evaluaated by a given source" do
+        Question.evaluated_by(:total_votes, @user).should == []
+      end
+      
+      it "should return an array of targets evaluated by a given source" do
+        user2 = User.create!(:name => 'katsuya')
+        question2 = Question.create!(:text => 'Question 2', :author_id => @user.id)
+        question3 = Question.create!(:text => 'Question 3', :author_id => @user.id)
+        @question.add_evaluation(:total_votes, 1, @user).should be_true
+        question2.add_evaluation(:total_votes, 2, user2).should be_true
+        question3.add_evaluation(:total_votes, 3, @user).should be_true
+        Question.evaluated_by(:total_votes, @user).should == [@question, question3]
+        Question.evaluated_by(:total_votes, user2).should == [question2]
+      end
+
+      context "With Scopes" do
+        it "should return an array of targets evaluated by a given source on appropriate scope" do
+          user2 = User.create!(:name => 'katsuya')
+          phrase2 = Phrase.create!(:text => "Two")
+          @phrase.add_evaluation(:difficulty_with_scope, 1, @user, :s1).should be_true
+          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2).should be_true
+          @phrase.add_evaluation(:difficulty_with_scope, 3, user2, :s2).should be_true
+          @phrase.add_evaluation(:difficulty_with_scope, 4, user2, :s3).should be_true
+          phrase2.add_evaluation(:difficulty_with_scope, 1, user2, :s1).should be_true
+          phrase2.add_evaluation(:difficulty_with_scope, 2, user2, :s2).should be_true
+          phrase2.add_evaluation(:difficulty_with_scope, 3, @user, :s2).should be_true
+          phrase2.add_evaluation(:difficulty_with_scope, 4, @user, :s3).should be_true
+          Phrase.evaluated_by(:difficulty_with_scope, @user, :s1).should == [@phrase]
+          Phrase.evaluated_by(:difficulty_with_scope, user2, :s1).should == [phrase2]
+          Phrase.evaluated_by(:difficulty_with_scope, @user, :s2).should == [@phrase, phrase2]
+          Phrase.evaluated_by(:difficulty_with_scope, user2, :s2).should == [@phrase, phrase2]
+          Phrase.evaluated_by(:difficulty_with_scope, @user, :s3).should == [phrase2]
+          Phrase.evaluated_by(:difficulty_with_scope, user2, :s3).should == [@phrase]
+        end
+
+        it "should raise exception if invalid scope is given" do
+          lambda{@phrase.add_evaluation(:difficulty_with_scope, 1, :invalid_scope)}.should raise_error(ArgumentError)
+        end
+
+        it "should raise exception if scope is not given" do
+          lambda{@phrase.add_evaluation(:difficulty_with_scope, 1)}.should raise_error(ArgumentError)
+        end
+      end
+    end
+
     describe "#add_evaluation" do
       it "should create evaluation in case of valid input" do
-        @question.add_evaluation(:total_votes, 1, @user)
+        @question.add_evaluation(:total_votes, 1, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 1
       end
 
@@ -48,8 +94,8 @@ describe ActiveRecord::Base do
 
       context "With Scopes" do
         it "should add evaluation on appropriate scope" do
-          @phrase.add_evaluation(:difficulty_with_scope, 1, @user, :s1)
-          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2)
+          @phrase.add_evaluation(:difficulty_with_scope, 1, @user, :s1).should be_true
+          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 1
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == 2
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0
@@ -67,30 +113,30 @@ describe ActiveRecord::Base do
 
     describe "#add_or_update_evaluation" do
       it "should create evaluation if it does not exist" do
-        @question.add_or_update_evaluation(:total_votes, 1, @user)
+        @question.add_or_update_evaluation(:total_votes, 1, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 1
       end
 
       it "should update evaluation if it exists already" do
         @question.add_evaluation(:total_votes, 1, @user)
-        @question.add_or_update_evaluation(:total_votes, 2, @user)
+        @question.add_or_update_evaluation(:total_votes, 2, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 2
       end
 
       context "With Scopes" do
         it "should add evaluation on appropriate scope if it does not exist" do
-          @phrase.add_or_update_evaluation(:difficulty_with_scope, 1, @user, :s1)
-          @phrase.add_or_update_evaluation(:difficulty_with_scope, 2, @user, :s2)
+          @phrase.add_or_update_evaluation(:difficulty_with_scope, 1, @user, :s1).should be_true
+          @phrase.add_or_update_evaluation(:difficulty_with_scope, 2, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 1
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == 2
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0
         end
 
         it "should update evaluation on appropriate scope if it exists already" do
-          @phrase.add_evaluation(:difficulty_with_scope, 1, @user, :s1)
-          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2)
-          @phrase.add_or_update_evaluation(:difficulty_with_scope, 3, @user, :s1)
-          @phrase.add_or_update_evaluation(:difficulty_with_scope, 5, @user, :s2)
+          @phrase.add_evaluation(:difficulty_with_scope, 1, @user, :s1).should be_true
+          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2).should be_true
+          @phrase.add_or_update_evaluation(:difficulty_with_scope, 3, @user, :s1).should be_true
+          @phrase.add_or_update_evaluation(:difficulty_with_scope, 5, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 3
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == 5
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0
@@ -104,7 +150,7 @@ describe ActiveRecord::Base do
       end
 
       it "should update evaluation in case of valid input" do
-        @question.update_evaluation(:total_votes, 2, @user)
+        @question.update_evaluation(:total_votes, 2, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 2
       end
 
@@ -122,11 +168,11 @@ describe ActiveRecord::Base do
 
       context "With Scopes" do
         before :each do
-          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2)
+          @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2).should be_true
         end
 
         it "should update evaluation on appropriate scope" do
-          @phrase.update_evaluation(:difficulty_with_scope, 5, @user, :s2)
+          @phrase.update_evaluation(:difficulty_with_scope, 5, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 0
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == 5
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0
@@ -192,7 +238,7 @@ describe ActiveRecord::Base do
       end
 
       it "should delete evaluation in case of valid input" do
-        @question.delete_evaluation(:total_votes, @user)
+        @question.delete_evaluation(:total_votes, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 0
       end
 
@@ -210,7 +256,7 @@ describe ActiveRecord::Base do
         end
 
         it "should delete evaluation on appropriate scope" do
-          @phrase.delete_evaluation(:difficulty_with_scope, @user, :s2)
+          @phrase.delete_evaluation(:difficulty_with_scope, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 0
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == 0
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0
@@ -228,13 +274,13 @@ describe ActiveRecord::Base do
 
     describe "#increase_evaluation" do
       it "should add evaluation if it does not exist" do
-        @question.increase_evaluation(:total_votes, 2, @user)
+        @question.increase_evaluation(:total_votes, 2, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 2
       end
 
       it "should increase evaluation if it exists already" do
         @question.add_evaluation(:total_votes, 1, @user)
-        @question.increase_evaluation(:total_votes, 2, @user)
+        @question.increase_evaluation(:total_votes, 2, @user).should be_true
         @question.reputation_value_for(:total_votes).should == 3
       end
 
@@ -244,7 +290,7 @@ describe ActiveRecord::Base do
         end
 
         it "should increase evaluation on appropriate scope" do
-          @phrase.increase_evaluation(:difficulty_with_scope, 5, @user, :s2)
+          @phrase.increase_evaluation(:difficulty_with_scope, 5, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 0
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == 7
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0
@@ -254,13 +300,13 @@ describe ActiveRecord::Base do
 
     describe "#decrease_evaluation" do
       it "should add evaluation if it does not exist" do
-        @question.decrease_evaluation(:total_votes, 2, @user)
+        @question.decrease_evaluation(:total_votes, 2, @user).should be_true
         @question.reputation_value_for(:total_votes).should == -2
       end
 
       it "should increase evaluation if it exists already" do
         @question.add_evaluation(:total_votes, 1, @user)
-        @question.decrease_evaluation(:total_votes, 2, @user)
+        @question.decrease_evaluation(:total_votes, 2, @user).should be_true
         @question.reputation_value_for(:total_votes).should == -1
       end
 
@@ -269,8 +315,8 @@ describe ActiveRecord::Base do
           @phrase.add_evaluation(:difficulty_with_scope, 2, @user, :s2)
         end
 
-        it "should increase evaluation on appropriate scope" do
-          @phrase.decrease_evaluation(:difficulty_with_scope, 5, @user, :s2)
+        it "should decrease evaluation on appropriate scope" do
+          @phrase.decrease_evaluation(:difficulty_with_scope, 5, @user, :s2).should be_true
           @phrase.reputation_value_for(:difficulty_with_scope, :s1).should == 0
           @phrase.reputation_value_for(:difficulty_with_scope, :s2).should == -3
           @phrase.reputation_value_for(:difficulty_with_scope, :s3).should == 0

data/spec/reputation_system/reputation_spec.rb

@@ -116,4 +116,47 @@ describe ActiveRecord::Base do
       end
     end
   end
+
+  context "Normalization" do
+    describe "#normalized_reputation_value_for" do
+      it "should return 0 as if there is no data" do
+        @question.normalized_reputation_value_for(:total_votes).should == 0
+      end
+
+      it "should return appropriate value in case of valid input" do
+        question2 = Question.create!(:text => 'Does this work too?', :author_id => @user.id)
+        question3 = Question.create!(:text => 'Does this work too?', :author_id => @user.id)
+        @question.add_evaluation(:total_votes, 1, @user)
+        question2.add_evaluation(:total_votes, 2, @user)
+        question3.add_evaluation(:total_votes, 3, @user)
+        @question.normalized_reputation_value_for(:total_votes).should == 0
+        question2.normalized_reputation_value_for(:total_votes).should == 0.5
+        question3.normalized_reputation_value_for(:total_votes).should == 1
+      end
+
+      it "should raise exception if invalid reputation name is given" do
+        lambda {@question.normalized_reputation_value_for(:invalid)}.should raise_error(ArgumentError)
+      end
+
+      it "should raise exception if scope is given for reputation with no scopes" do
+        lambda {@question.normalized_reputation_value_for(:difficulty, :s1)}.should raise_error(ArgumentError)
+      end
+
+      it "should raise exception if scope is not given for reputation with scopes" do
+        lambda {@phrase.normalized_reputation_value_for(:difficulty_with_scope)}.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "#exclude_all_reputations_for_normalization" do
+      it "should activate all reputation" do
+        @question2 = Question.create!(:text => 'Does this work??', :author_id => @user.id)
+        @question2.add_evaluation(:total_votes, 70, @user)
+        @question.add_evaluation(:total_votes, 100, @user)
+        @question.deactivate_all_reputations
+        RSReputation.maximum(:value, :conditions => {:reputation_name => 'total_votes', :active => true}).should == 70
+        @question.activate_all_reputations
+        RSReputation.maximum(:value, :conditions => {:reputation_name => 'total_votes', :active => true}).should == 100
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-reputation-system
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-14 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70099784737000 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70099784737000
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70099784736120 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: 0.8.7
   type: :development
   prerelease: false
-  version_requirements: *70099784736120
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70099784735280 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +53,15 @@ dependencies:
         version: '2.8'
   type: :development
   prerelease: false
-  version_requirements: *70099784735280
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70099784734240 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70099784734240
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &70099790085800 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +85,15 @@ dependencies:
         version: 0.7.1
   type: :development
   prerelease: false
-  version_requirements: *70099790085800
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70099790085300 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +101,12 @@ dependencies:
         version: 1.3.5
   type: :development
   prerelease: false
-  version_requirements: *70099790085300
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
 description: ActiveRecord Reputation System gem allows rails apps to compute and publish
   reputation scores for active record models.
 email:
@@ -99,7 +129,6 @@ files:
 - lib/reputation_system/base.rb
 - lib/reputation_system/evaluation.rb
 - lib/reputation_system/network.rb
-- lib/reputation_system/normalization.rb
 - lib/reputation_system/query.rb
 - lib/reputation_system/reputation.rb
 - lib/reputation_system/scope.rb
@@ -111,7 +140,6 @@ files:
 - spec/reputation_system/base_spec.rb
 - spec/reputation_system/evaluation_spec.rb
 - spec/reputation_system/network_spec.rb
-- spec/reputation_system/normalization_spec.rb
 - spec/reputation_system/query_spec.rb
 - spec/reputation_system/reputation_spec.rb
 - spec/reputation_system/scope_spec.rb
@@ -128,15 +156,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1595828597124955977
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1595828597124955977
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: ActiveRecord Reputation System gem allows rails apps to compute and publish

data/lib/reputation_system/normalization.rb

@@ -1,50 +0,0 @@
-##
-#  Copyright 2012 Twitter, Inc
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#  http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-##
-
-module ReputationSystem
-  module Normalization
-    def normalized_reputation_value_for(reputation_name, *args)
-      scope = args.first
-      if !self.class.has_reputation_for?(reputation_name)
-        raise ArgumentError, "#{reputation_name} is not valid"
-      else
-        reputation_name = ReputationSystem::Network.get_scoped_reputation_name(self.class.name, reputation_name, scope)
-        process = ReputationSystem::Network.get_reputation_def(self.class.name, reputation_name)[:aggregated_by]
-        reputation = RSReputation.find_or_create_reputation(reputation_name, self, process)
-        reputation.normalized_value
-      end
-    end
-
-    def activate_all_reputations
-      RSReputation.find(:all, :conditions => {:target_id => self.id, :target_type => self.class.name, :active => false}).each do |r|
-        r.active = true
-        r.save!
-      end
-    end
-
-    def deactivate_all_reputations
-      RSReputation.find(:all, :conditions => {:target_id => self.id, :target_type => self.class.name, :active => true}).each do |r|
-        r.active = false
-        r.save!
-      end
-    end
-
-    def reputations_activated?(reputation_name)
-      r = RSReputation.find(:first, :conditions => {:reputation_name => reputation_name.to_s, :target_id => self.id, :target_type => self.class.name})
-      r ? r.active : false
-    end
-  end
-end

data/spec/reputation_system/normalization_spec.rb

@@ -1,68 +0,0 @@
-##
-#  Copyright 2012 Twitter, Inc
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#  http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-##
-
-require 'spec_helper'
-
-describe ActiveRecord::Base do
-
-  before(:each) do
-    @user = User.create!(:name => 'jack')
-    @question = Question.create!(:text => 'Does this work?', :author_id => @user.id)
-    @answer = Answer.create!(:text => 'Yes!', :author_id => @user.id, :question_id => @question.id)
-    @phrase = Phrase.create!(:text => "One")
-  end
-
-  describe "#normalized_reputation_value_for" do
-    it "should return 0 as if there is no data" do
-      @question.normalized_reputation_value_for(:total_votes).should == 0
-    end
-
-    it "should return appropriate value in case of valid input" do
-      question2 = Question.create!(:text => 'Does this work too?', :author_id => @user.id)
-      question3 = Question.create!(:text => 'Does this work too?', :author_id => @user.id)
-      @question.add_evaluation(:total_votes, 1, @user)
-      question2.add_evaluation(:total_votes, 2, @user)
-      question3.add_evaluation(:total_votes, 3, @user)
-      @question.normalized_reputation_value_for(:total_votes).should == 0
-      question2.normalized_reputation_value_for(:total_votes).should == 0.5
-      question3.normalized_reputation_value_for(:total_votes).should == 1
-    end
-
-    it "should raise exception if invalid reputation name is given" do
-      lambda {@question.normalized_reputation_value_for(:invalid)}.should raise_error(ArgumentError)
-    end
-
-    it "should raise exception if scope is given for reputation with no scopes" do
-      lambda {@question.normalized_reputation_value_for(:difficulty, :s1)}.should raise_error(ArgumentError)
-    end
-
-    it "should raise exception if scope is not given for reputation with scopes" do
-      lambda {@phrase.normalized_reputation_value_for(:difficulty_with_scope)}.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "#exclude_all_reputations_for_normalization" do
-    it "should activate all reputation" do
-      @question2 = Question.create!(:text => 'Does this work??', :author_id => @user.id)
-      @question2.add_evaluation(:total_votes, 70, @user)
-      @question.add_evaluation(:total_votes, 100, @user)
-      @question.deactivate_all_reputations
-      RSReputation.maximum(:value, :conditions => {:reputation_name => 'total_votes', :active => true}).should == 70
-      @question.activate_all_reputations
-      RSReputation.maximum(:value, :conditions => {:reputation_name => 'total_votes', :active => true}).should == 100
-    end
-  end
-end