reputation 0.0.2

data/.infinity_test

@@ -0,0 +1,35 @@
+infinity_test do
+
+  notifications :growl do
+    show_images :mode => :mario_bros
+  end
+
+  use :rubies => %w(1.9.2 1.9.1 1.8.7 ree jruby macruby rbx), :test_framework => :rspec
+
+  # use :specific_options => {'jruby' => 'J-cp bar/whisky-in-the.jar:.'}
+
+  before(:each_ruby) do |environment|
+    # ...
+  end
+
+  after(:each_ruby) do |environment|
+    # ...
+  end
+
+  before_run do
+    clear :terminal
+  end
+
+  after_run do
+    # ...
+  end
+
+  #heuristics('my_pattern') do |file|
+    # ...
+  #end
+
+  replace_patterns do |application|
+    # ...
+  end
+
+end

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--tty

data/app/models/reputation_behaviour.rb

@@ -0,0 +1,38 @@
+class ReputationBehaviour < ActiveRecord::Base
+  
+  belongs_to :user
+  belongs_to :rule, :class_name => 'ReputationRule'
+  
+  before_save :recalculate_rule
+  
+  attr_accessible :user, :rule, :metric
+  
+  validates_presence_of :user
+  validates_presence_of :rule
+  validates_numericality_of :metric
+  
+  validates_uniqueness_of :user_id, :scope => :rule_id
+  
+  # Set the rule, can either be a ReputationRule or the name of the rule
+  #
+  # @example
+  #   behaviour.rule = 'rule_1'
+  #   # or
+  #   behaviour.rule = ReputationRule.find(:first)
+  
+  def rule=(rule)
+    write_attribute :rule_id, case rule
+    when ReputationRule
+      rule.id
+    else 
+      ReputationRule.find_by_name( rule ).try(:id)
+    end
+  end
+  
+private
+
+  def recalculate_rule
+    rule.recalculate_intermediate_values_for user
+  end
+  
+end

data/app/models/reputation_intermediate_value.rb

@@ -0,0 +1,22 @@
+class ReputationIntermediateValue < ActiveRecord::Base
+    
+  belongs_to :user
+  belongs_to :rule, :class_name => 'ReputationRule'
+  
+  validates_presence_of :user
+  validates_presence_of :rule
+  validates_numericality_of :value
+  
+  validates_uniqueness_of :name, :scope => [:user_id, :rule_id]
+  
+  attr_accessible :user, :rule, :name, :value
+  
+  def initialize(args = {})
+    options = {
+      :value => 0
+    }.merge(args)
+
+    super options
+  end
+    
+end

data/app/models/reputation_rule.rb

@@ -0,0 +1,107 @@
+class ReputationRule < ActiveRecord::Base
+  
+  has_many :intermediate_values, :class_name => 'ReputationIntermediateValue', :foreign_key => 'rule_id'
+  has_many :behaviours,          :class_name => 'ReputationBehaviour',         :foreign_key => 'rule_id'
+  
+  serialize :constants,           Hash
+  serialize :aggregate_constants, Hash
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  validates_numericality_of :weight, :only_integer => true, :greater_than => 0
+  
+  attr_accessible :name, :kind, :weight, :function, :constants, :aggregate_function, :aggregate_constants
+  
+  attr_readonly :kind
+  
+  def initialize(*args)
+    args[0] = {
+      :weight => 1,
+      :kind => 'singular',
+      :function => 'linear',
+      :constants => { :m => 1 },
+      :aggregate_function => 'linear',
+      :aggregate_constants => { :m => 1 }
+    }.merge(args.first||{})
+
+    super *args
+  end
+  
+  # Return the total score for a certain user
+  #
+  # @param [User]
+  def self.value_for(user)
+    all.inject(0){|total,r| total + r.value_for( user ) }
+  end
+  
+  # Lookup the weighting relative to all other rules
+  #
+  def normalized_weighting
+    BigDecimal(weight.to_s) / ReputationRule.sum('weight')
+  end
+  
+  # Calculate the score for a certain user
+  #
+  # @param [User]
+  def value_for(user)
+    behaviour = user.behaviours.find_by_rule_id id
+    if behaviour
+      case kind
+      when 'singular'
+        f(behaviour.metric) * normalized_weighting
+      when 'collection'
+        ivo = intermediate_values.find_by_user_id_and_name(user.id,kind)
+        iv = ivo ? ivo.value : 0
+        aggregate_f( 
+          f(behaviour.metric) + iv
+        ) * normalized_weighting
+      end
+    else
+      0
+    end
+  end
+  
+  # Return the function object defined by :function and :constants
+  #
+  # @return [Reputation::Functions::Linear, Reputation::Functions::Step, Reputation::Functions::GeneralisedLogisticCurve]
+  def function
+    build_function(super, constants)
+  end
+  
+  # Return the aggregate function object defined by :aggregate_function and :aggregate_constants
+  #
+  # @return [Reputation::Functions::Linear, Reputation::Functions::Step, Reputation::Functions::GeneralisedLogisticCurve]
+  def aggregate_function
+    build_function(super, aggregate_constants)
+  end
+  
+  def recalculate_intermediate_values_for(user) # :nodoc:
+    behaviour = user.behaviours.find_by_rule_id(self.id)
+    if behaviour
+      case kind
+      when 'collection'
+        iv = intermediate_values.find_by_user_id_and_name(user.id,kind) || intermediate_values.build(:user => user, :name => kind)
+        iv.value += f(behaviour.metric)
+        iv.save!
+      end
+    end
+  end
+  
+private
+
+  # Delegate f to the function#f
+  def f(*args)
+    function.f(*args)
+  end
+  
+  # Delegate aggregate_f to the aggregate_function#f
+  def aggregate_f(*args)
+    aggregate_function.f(*args)
+  end
+
+  def build_function(name, constants)
+    klass = "Reputation::Functions::#{name.to_s.camelcase}".constantize
+    klass.new(constants)
+  end
+  
+end

data/generators/reputation/reputation_generator.rb

@@ -0,0 +1,11 @@
+class ReputationGenerator < Rails::Generator::Base
+  
+  def manifest
+    
+    record do |m|
+      m.migration_template "reputation_create_tables.rb", "db/migrate", :migration_file_name => "reputation_create_tables"
+    end
+    
+  end
+  
+end

data/generators/reputation/templates/reputation_create_tables.rb

@@ -0,0 +1,37 @@
+class ReputationCreateTables < ActiveRecord::Migration
+  def self.up
+    create_table :reputation_rules do |t|
+      t.string  :name
+      t.integer :weight
+      t.string  :kind
+      t.string  :function
+      t.string  :constants
+      t.string  :aggregate_function
+      t.string  :aggregate_constants      
+    end
+
+    create_table :reputation_intermediate_values do |t|
+      t.references :user
+      t.references :rule
+      t.string     :name
+      t.decimal    :value
+    end
+    add_index :reputation_intermediate_values, :user_id
+    add_index :reputation_intermediate_values, :rule_id
+    add_index :reputation_intermediate_values, :name
+
+    create_table :reputation_behaviours do |t|
+      t.references :user
+      t.references :rule
+      t.decimal    :metric
+    end
+    add_index :reputation_behaviours, :user_id
+    add_index :reputation_behaviours, :rule_id
+  end
+
+  def self.down
+    drop_table :reputation_rules
+    drop_table :reputation_user_rule
+    drop_table :reputation_behaviours
+  end
+end

data/lib/reputation.rb

@@ -0,0 +1,3 @@
+require 'reputation/user'
+require 'reputation/functions'
+require 'reputation/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3

data/lib/reputation/engine.rb

@@ -0,0 +1,8 @@
+require "reputation"
+require "rails"
+
+class Reputation
+  class Engine < Rails::Engine
+    
+  end
+end

data/lib/reputation/functions.rb

@@ -0,0 +1,4 @@
+require "reputation/functions/mixin"
+require "reputation/functions/linear"
+require "reputation/functions/step"
+require "reputation/functions/generalised_logistic_curve"

data/lib/reputation/functions/generalised_logistic_curve.rb

@@ -0,0 +1,37 @@
+class Reputation
+  class Functions
+    class GeneralisedLogisticCurve
+      
+      include Mixin
+      
+      attr_accessor :a, :k, :b, :v, :q, :m
+      
+      def initialize(args = {})
+        constants = { 
+          :a => -1,  # lower asymptote
+          :k => 1,   # upper asymptote
+          :b => 10,  # growth rate
+          :v => 0.5, # affects near which asymptote maximum growth occurs
+          :q => 0.5, # depends on the value Y(0)
+          :m => 0, # the time of maximum growth if Q=v
+        }.merge( args )
+        @a = constants[:a]
+        @k = constants[:k]
+        @b = constants[:b]
+        @v = constants[:v]
+        @q = constants[:q]
+        @m = constants[:m]
+      end
+      
+      def f(t)
+        limit( 
+          a.to_f + (
+            (k.to_f - a.to_f) /
+            (1 + q.to_f * Math.exp(-1 * b.to_f*(t.to_f-m.to_f)) )**(1.to_f/v.to_f)
+          )
+        )
+      end
+      
+    end
+  end
+end

data/lib/reputation/functions/linear.rb

@@ -0,0 +1,21 @@
+class Reputation
+  class Functions
+    class Linear
+      
+      include Mixin
+      
+      attr_accessor :m
+      
+      def initialize(args = {})
+        constants = { :m => 1 }.merge( args )
+        @m = constants[:m]
+      end
+      
+      def f(x)
+        limit x * m
+      end
+      
+    end
+    
+  end
+end

data/lib/reputation/functions/mixin.rb

@@ -0,0 +1,44 @@
+require "googlecharts"
+require "launchy"
+
+class Reputation
+  class Functions
+    module Mixin
+      
+      # Produces the URL for a google chart of the function
+      #
+      def google_chart_url
+        points = 1000
+        range = Array.new(points){|i| (i-points/2) * 0.01 }
+        y = range.map{|x| f(x) }
+        c = Googlecharts.line(
+          :size => '800x200',
+          :axis_with_labels => 'x,y',
+          :title => self.class.name,
+          :data => y,
+          :axis_range => [[range.first,range.last],[y.min,y.max]]
+        )
+      end
+      
+      # Opens the google chart for the function in the browser
+      #
+      def google_chart
+        Launchy::Browser.run google_chart_url
+      end
+    
+    private
+      
+      def limit(r)
+        if r > 1
+          1
+        elsif r < -1
+          -1
+        else
+          r
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/reputation/functions/step.rb

@@ -0,0 +1,27 @@
+class Reputation
+  class Functions
+    class Step
+      
+      include Mixin
+      
+      attr_accessor :a, :k, :c
+      
+      def initialize(args = {})
+        constants = {
+          :a => -1,  # lower asymptote
+          :k => 1,   # upper asymptote
+          :c => 0.5  # point of switch
+        }.merge( args )
+        @c = constants[:c]
+        @k = constants[:k]
+        @a = constants[:a]
+      end
+      
+      def f(x)
+        limit( x.to_f >= c.to_f ? k : a )
+      end
+      
+    end
+    
+  end
+end

data/lib/reputation/user.rb

@@ -0,0 +1,38 @@
+class Reputation  
+  module User
+    
+    def self.included(model)
+      model.send(:include, InstanceMethods)
+      model.send(:include, Relations)
+    end
+    
+    module Relations
+      def self.included(model)
+        model.class_eval do
+          
+          has_many :behaviours, :class_name => "ReputationBehaviour" do
+            def add(rule, metric)
+              rule = ReputationRule.find_by_name rule unless rule.is_a? ReputationRule
+              b = proxy_reflection.klass.find_by_user_id_and_rule_id proxy_owner.id, rule.id
+              b ||= proxy_reflection.klass.new :rule => rule, :user => proxy_owner
+              b.update_attribute :metric, metric
+              proxy_owner.behaviours(true)
+              b
+            end  
+          end
+          
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      # Returns the reputation value for the user
+      #
+      def reputation
+        ReputationRule.value_for(self)
+      end
+    end
+    
+  end
+end