activerecord-reputation-system 1.5.1 → 2.0.0

data/lib/reputation_system/models/evaluation.rb

@@ -0,0 +1,73 @@
+##
+#  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
+  class Evaluation < ActiveRecord::Base
+    self.table_name = 'rs_evaluations'
+
+    belongs_to :source, :polymorphic => true
+    belongs_to :target, :polymorphic => true
+    has_one :sent_messages, :as => :sender, :class_name => 'ReputationSystem::ReputationMessage', :dependent => :destroy
+
+    attr_accessible :reputation_name, :value, :source, :source_id, :source_type, :target, :target_id, :target_type
+
+    # Sets an appropriate source type in case of Single Table Inheritance.
+    before_validation :set_source_type_for_sti
+
+    # the same source cannot evaluate the same target more than once.
+    validates_uniqueness_of :source_id, :scope => [:reputation_name, :source_type, :target_id, :target_type]
+    validate :source_must_be_defined_for_reputation_in_network
+
+    def self.find_by_reputation_name_and_source_and_target(reputation_name, source, target)
+      source_type = get_source_type_for_sti(source, target.class.name, reputation_name)
+      ReputationSystem::Evaluation.find(:first,
+                        :conditions => {:reputation_name => reputation_name.to_s,
+                                        :source_id => source.id,
+                                        :source_type => source_type,
+                                        :target_id => target.id,
+                                        :target_type => target.class.name
+                                        })
+    end
+
+    def self.create_evaluation(reputation_name, value, source, target)
+      ReputationSystem::Evaluation.create!(:reputation_name => reputation_name.to_s, :value => value,
+                           :source_id => source.id, :source_type => source.class.name,
+                           :target_id => target.id, :target_type => target.class.name)
+    end
+
+    protected
+
+      def self.get_source_type_for_sti(source, target_type, reputation_name)
+        valid_source_type = ReputationSystem::Network.get_reputation_def(target_type, reputation_name)[:source].to_s.camelize
+        source_class = source.class
+        while source_class && valid_source_type != source_class.name && source_class.name != "ActiveRecord::Base"
+          source_class = source_class.superclass
+        end
+        source_class ? source_class.name : nil
+      end
+
+      def set_source_type_for_sti
+        sti_source_type = self.class.get_source_type_for_sti(source, target_type, reputation_name)
+        self.source_type = sti_source_type if sti_source_type
+      end
+
+      def source_must_be_defined_for_reputation_in_network
+        unless source_type == ReputationSystem::Network.get_reputation_def(target_type, reputation_name)[:source].to_s.camelize
+          errors.add(:source_type, "#{source_type} is not source of #{reputation_name} reputation")
+        end
+      end
+  end
+end

data/lib/reputation_system/models/reputation.rb

@@ -0,0 +1,211 @@
+##
+#  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
+  class Reputation < ActiveRecord::Base
+    self.table_name = 'rs_reputations'
+
+    belongs_to :target, :polymorphic => true
+    has_many :received_messages, :class_name => 'ReputationSystem::ReputationMessage', :foreign_key => :receiver_id, :dependent => :destroy do
+      def from(sender)
+        self.find_by_sender_id_and_sender_type(sender.id, sender.class.to_s)
+      end
+    end
+    has_many :sent_messages, :as => :sender, :class_name => 'ReputationSystem::ReputationMessage', :dependent => :destroy
+
+    attr_accessible :reputation_name, :value, :aggregated_by, :active, :target, :target_id, :target_type, :received_messages
+
+    before_validation :set_target_type_for_sti
+    before_save :change_zero_value_in_case_of_product_process
+
+    VALID_PROCESSES = ['sum', 'average', 'product']
+    validates_inclusion_of :aggregated_by, :in => VALID_PROCESSES, :message => "Value chosen for aggregated_by is not valid process"
+    validates_uniqueness_of :reputation_name, :scope => [:target_id, :target_type]
+
+    def self.find_by_reputation_name_and_target(reputation_name, target)
+      target_type = get_target_type_for_sti(target, reputation_name)
+      ReputationSystem::Reputation.find_by_reputation_name_and_target_id_and_target_type(reputation_name.to_s, target.id, target_type)
+    end
+
+    # All external access to reputation should use this since they are created lazily.
+    def self.find_or_create_reputation(reputation_name, target, process)
+      rep = find_by_reputation_name_and_target(reputation_name, target)
+      rep ? rep : create_reputation(reputation_name, target, process)
+    end
+
+    def self.create_reputation(reputation_name, target, process)
+      create_options = {:reputation_name => reputation_name.to_s, :target_id => target.id,
+                        :target_type => target.class.name, :aggregated_by => process.to_s}
+      rep = create(create_options)
+      initialize_reputation_value(rep, target, process)
+    end
+
+    def self.update_reputation_value_with_new_source(rep, source, weight, process)
+      weight ||= 1 # weight is 1 by default.
+      size = rep.received_messages.size
+      valueBeforeUpdate = size > 0 ? rep.value : nil
+      newValue = source.value
+      case process.to_sym
+      when :sum
+        rep.value += (newValue * weight)
+      when :average
+        rep.value = (rep.value * size + newValue * weight) / (size + 1)
+      when :product
+        rep.value *= (newValue * weight)
+      else
+        raise ArgumentError, "#{process} process is not supported yet"
+      end
+      save_succeeded = rep.save
+      ReputationSystem::ReputationMessage.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, newSize, weight, process)
+      weight ||= 1 # weight is 1 by default.
+      oldSize = rep.received_messages.size
+      valueBeforeUpdate = oldSize > 0 ? rep.value : nil
+      newValue = source.value
+      if newSize == 0
+        rep.value = process.to_sym == :product ? 1 : 0
+      else
+        case process.to_sym
+        when :sum
+          rep.value += (newValue - oldValue) * weight
+        when :average
+          rep.value = (rep.value * oldSize + (newValue - oldValue) * weight) / newSize
+        when :product
+          rep.value = (rep.value * newValue) / oldValue
+        else
+          raise ArgumentError, "#{process} process is not supported yet"
+        end
+      end
+      save_succeeded = rep.save
+      propagate_updated_reputation_value(rep, valueBeforeUpdate) if rep.target
+      save_succeeded
+    end
+
+    def normalized_value
+      if self.active == 1 || self.active == true
+        max = ReputationSystem::Reputation.max(self.reputation_name, self.target_type)
+        min = ReputationSystem::Reputation.min(self.reputation_name, self.target_type)
+        if max && min
+          range = max - min
+          range == 0 ? 0 : (self.value - min) / range
+        else
+          0
+        end
+      else
+        0
+      end
+    end
+
+    protected
+
+      # Updates reputation value for new reputation if its source already exist.
+      def self.initialize_reputation_value(receiver, target, process)
+        name = receiver.reputation_name
+        unless ReputationSystem::Network.is_primary_reputation?(target.class.name, name)
+          sender_defs = ReputationSystem::Network.get_reputation_def(target.class.name, name)[:source]
+          sender_defs.each do |sd|
+            sender_targets = target.get_attributes_of(sd)
+            sender_targets.each do |st|
+              update_reputation_if_source_exist(sd, st, receiver, process) if receiver.target
+            end
+          end
+        end
+        receiver
+      end
+
+      # Propagates updated reputation value to the reputations whose source is the updated reputation.
+      def self.propagate_updated_reputation_value(sender, oldValue)
+        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
+          newSize = receiver.received_messages.size
+          update_reputation_value_with_updated_source(receiver, sender, oldValue, newSize, weight, process)
+        end
+      end
+
+      def self.update_reputation_if_source_exist(sd, st, receiver, process)
+        scope = receiver.target.evaluate_reputation_scope(sd[:scope])
+        srn = ReputationSystem::Network.get_scoped_reputation_name(st.class.name, sd[:reputation], scope)
+        source = find_by_reputation_name_and_target(srn, st)
+        if source
+          update_reputation_value_with_new_source(receiver, source, sd[:weight], process)
+          ReputationSystem::ReputationMessage.add_reputation_message_if_not_exist(source, receiver)
+        end
+      end
+
+      def self.max(reputation_name, target_type)
+        ReputationSystem::Reputation.maximum(:value,
+                             :conditions => {:reputation_name => reputation_name.to_s, :target_type => target_type, :active => true})
+      end
+
+      def self.min(reputation_name, target_type)
+        ReputationSystem::Reputation.minimum(:value,
+                             :conditions => {:reputation_name => reputation_name.to_s, :target_type => target_type, :active => true})
+      end
+
+      def self.get_target_type_for_sti(target, reputation_name)
+        target_class = target.class
+        defs = ReputationSystem::Network.get_reputation_defs(target_class.name)[reputation_name.to_sym]
+        while target_class && target_class.name != "ActiveRecord::Base" && defs && defs.empty?
+          target_class = target_class.superclass
+          defs = ReputationSystem::Network.get_reputation_defs(target_class.name)[reputation_name.to_sym]
+        end
+        target_class ? target_class.name : nil
+      end
+
+      def set_target_type_for_sti
+        sti_target_type = self.class.get_target_type_for_sti(target, reputation_name)
+        self.target_type = sti_target_type if sti_target_type
+      end
+
+      def change_zero_value_in_case_of_product_process
+        self.value = 1 if self.value == 0 && self.aggregated_by == "product"
+      end
+
+      def remove_associated_messages
+        ReputationSystem::ReputationMessage.delete_all(:sender_type => self.class.name, :sender_id => self.id)
+        ReputationSystem::ReputationMessage.delete_all(:receiver_id => self.id)
+      end
+  end
+end

data/lib/reputation_system/models/reputation_message.rb

@@ -0,0 +1,49 @@
+##
+#  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
+  class ReputationMessage < ActiveRecord::Base
+    self.table_name = 'rs_reputation_messages'
+    belongs_to :sender, :polymorphic => true
+    belongs_to :receiver, :class_name => 'ReputationSystem::Reputation'
+
+    attr_accessible :weight, :sender, :receiver
+
+    # The same sender cannot send massage to the same receiver more than once.
+    validates_uniqueness_of :receiver_id, :scope => [:sender_id, :sender_type]
+    validate :sender_must_be_evaluation_or_reputation
+
+    after_destroy :delete_sender_if_evaluation
+
+    def self.add_reputation_message_if_not_exist(sender, receiver)
+      rm = create(:sender => sender, :receiver => receiver)
+      receiver.received_messages.push rm if rm.valid?
+    end
+
+    protected
+
+      def delete_sender_if_evaluation
+        sender.destroy if sender.is_a?(ReputationSystem::Evaluation)
+      end
+
+      def sender_must_be_evaluation_or_reputation
+        unless sender.is_a?(ReputationSystem::Evaluation) || sender.is_a?(ReputationSystem::Reputation)
+          errors.add(:sender, "must be an evaluation or a reputation")
+        end
+      end
+        
+  end
+end

data/lib/reputation_system/network.rb

@@ -34,6 +34,7 @@ module ReputationSystem
           reputation_def = reputation_defs[reputation_name.to_sym]
           if reputation_def == {}
             begin
+              # This recursion finds reputation definition in the ancestor in case of STI.
               klass = class_name.constantize.superclass
               reputation_def = get_reputation_def(klass.name, reputation_name) if klass
             rescue NameError
@@ -49,6 +50,7 @@ module ReputationSystem
         options[:source] = convert_to_array_if_hash(options[:source])
         options[:source_of] ||= []
         options[:source_of] = convert_to_array_if_hash(options[:source_of])
+        options[:aggregated_by] = options[:aggregated_by] || :sum
         assign_self_as_default_value_for_of_attr(options[:source])
         assign_self_as_default_value_for_of_attr(options[:source_of])
         reputation_defs[reputation_name] = options

data/lib/reputation_system/query_builder.rb

@@ -27,8 +27,8 @@ module ReputationSystem
       def build_select_statement(table_name, reputation_name, select=nil, srn=nil, normalize=false)
         select = sanitize_sql_array(["%s.*", table_name]) unless select
         if normalize
-          max = RSReputation.max(srn, self.name)
-          min = RSReputation.min(srn, self.name)
+          max = ReputationSystem::Reputation.max(srn, self.name)
+          min = ReputationSystem::Reputation.min(srn, self.name)
           range = max - min
           if range < DELTA
             sanitize_sql_array(["%s, (0) AS normalized_%s", select, reputation_name])
@@ -42,8 +42,8 @@ module ReputationSystem
 
       def build_select_statement_with_reputation_only(table_name, reputation_name, srn=nil, normalize=false)
         if normalize
-          max = RSReputation.max(srn, self.name)
-          min = RSReputation.min(srn, self.name)
+          max = ReputationSystem::Reputation.max(srn, self.name)
+          min = ReputationSystem::Reputation.min(srn, self.name)
           range = max - min
           if range < DELTA
             sanitize_sql_array(["(0) AS normalized_%s", reputation_name])

data/lib/reputation_system/{reputation.rb → reputation_methods.rb}

@@ -15,41 +15,31 @@
 ##
 
 module ReputationSystem
-  module Reputation
-    def reputation_value_for(reputation_name, *args)
-      warn "[DEPRECATION] `reputation_value_for` will be deprecated in version 2.0.0. Please use `reputation_for` instead."
-      reputation_for(reputation_name, *args)
-    end
-
+  module ReputationMethods
     def reputation_for(reputation_name, *args)
       find_reputation(reputation_name, args.first).value
     end
 
-    def normalized_reputation_value_for(reputation_name, *args)
-      warn "[DEPRECATION] `normalized_reputation_value_for` will be deprecated in version 2.0.0. Please use `normalized_reputation_for` instead."
-      normalized_reputation_for(reputation_name, *args)
-    end
-
     def normalized_reputation_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|
+      ReputationSystem::Reputation.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|
+      ReputationSystem::Reputation.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 = ReputationSystem::Reputation.find(:first, :conditions => {:reputation_name => reputation_name.to_s, :target_id => self.id, :target_type => self.class.name})
       r ? r.active : false
     end
 
@@ -66,7 +56,7 @@ module ReputationSystem
         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)
+        ReputationSystem::Reputation.find_or_create_reputation(srn, self, process)
       end
   end
 end

data/lib/reputation_system/{scope.rb → scope_methods.rb}

@@ -15,7 +15,7 @@
 ##
 
 module ReputationSystem
-  module Scope
+  module ScopeMethods
     def self.included(klass)
       klass.extend ClassMethods
     end
@@ -34,4 +34,4 @@ module ReputationSystem
       end
     end
   end
-end
+end

data/lib/reputation_system/version.rb

@@ -15,5 +15,5 @@
 ##
 
 module ReputationSystem
-  VERSION = "1.5.1"
+  VERSION = "2.0.0"
 end