merit 0.1.3

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem "rails", "3.0.10"
+gem "sqlite3"
+gem "haml"
+gem "capybara"

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+== MIT License
+
+Copyright (c) 2011 [Tute Costa - tutecosta@gmail.com]
+
+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.rdoc

@@ -0,0 +1,127 @@
+= Merit Rails Gem
+
+Define reputation for users and data on your application.
+
+http://i567.photobucket.com/albums/ss118/DeuceBigglebags/th_nspot26_300.jpg
+
+
+= Installation
+
+1. Add 'merit' to your Gemfile
+2. Run +rails+ +g+ +merit+:+install+
+3. Run +rails+ +g+ +merit+ +MODEL_NAME+
+4. Run +rake+ +db+:+migrate+
+5. Configure reputation rules for your application
+
+
+= Defining badge rules
+
+You may give badges to any resource on your application if some condition
+holds. Badges may have levels, and may be temporary.
+
+Define rules on +app/models/merit_badge_rules.rb+:
+
++grant_on+ accepts:
+* +controller+#+action+ string (similar to Rails routes)
+* :+badge+ for badge name
+* :+level+ for badge level
+* :+to+: method name over target_object which obtains user to badge.
+* :+temporary+ (boolean): if the condition doesn't hold and the receiver had
+  the badge, it gets removed. +false+ by default (badges are kept forever).
+* &+block+
+  * empty (always grants)
+  * a block which evaluates to boolean (recieves target object as parameter)
+  * a block with a hash composed of methods to run on the target object with
+    expected values
+
+== Examples
+
+    grant_on 'comments#vote', :badge => 'relevant-commenter', :to => :user do
+      { :votes => 5 }
+    end
+
+    grant_on ['users#create', 'users#update'], :badge => 'autobiographer', :temporary => true do |user|
+      user.name.present? && user.address.present?
+    end
+
+
+= Defining point rules
+
+Points are a simple integer value which are given to "meritable" resources.
+They are given on actions-triggered, either to the action user or to the
+method (or array of methods) defined in the +:to+ option.
+
+Define rules on +app/models/merit_point_rules.rb+:
+
+== Examples
+
+    score 10, :on => [
+      'users#update'
+    ]
+
+    score 15, :on => 'reviews#create', :to => [:reviewer, :reviewed]
+
+    score 20, :on => [
+      'comments#create',
+      'photos#create'
+    ]
+
+
+= Defining rank rules
+
+Rankings are very similar to badges. They give "badges" which have a hierarchy
+defined by +level+'s lexicografical order (greater is better). If a rank is
+granted, lower level ranks are taken off. 5 stars is a common ranking use
+case.
+
+They are not given at specified actions like badges, you should define a cron
+job to test if ranks are to be granted.
+
+Define rules on +app/models/merit_rank_rules.rb+:
+
++set_rank+ accepts:
+* +badge_name+ name of this ranking
+* :+level+ ranking level (greater is better)
+* :+to+ model or scope to check if new rankings apply
+
+Check for rules on a rake task executed in background like:
+    task :cron => :environment do
+      MeritRankRules.new.check_rank_rules
+    end
+
+
+== Examples
+
+    set_rank :stars, :level => 2, :to => Commiter.active do |commiter|
+      commiter.branches > 1 && commiter.followers >= 10
+    end
+
+    set_rank :stars, :level => 3, :to => Commiter.active do |commiter|
+      commiter.branches > 2 && commiter.followers >= 20
+    end
+
+
+= Grant manually
+
+You may also add badges/rank "by hand" from controller actions:
+   Badge.find(3).grant_to(current_user)
+
+
+= Test application
+
+To run the test application inside this gem follow:
+1. cd test/dummy
+2. rails g merit:install
+3. rails g merit user
+4. rake db:migrate ; rake db:seed
+5. rails s
+
+
+= To-do list
+
+* Test points granting with different options.
+* Ranking should not be badges, so .badges doesn't return them (2-stars shouldn't be badge).
+* grep -r 'FIXME\|TODO' .
+* :value parameter (for star voting for example) should be configurable (depends
+  on params[:value] on the controller).
+* Make fixtures for integration testing (now creating objects on test file!).

data/Rakefile

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rake/rdoctask'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Merit'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/app/models/badge.rb

@@ -0,0 +1,39 @@
+class Badge < ActiveRecord::Base
+  has_many :badges_sashes
+  has_many :sashes, :through => :badges_sashes
+
+  # Grant badge to sash
+  def grant_to(object_or_sash)
+    object_or_sash.create_sash_if_none unless object_or_sash.kind_of?(Sash)
+    sash = object_or_sash.respond_to?(:sash) ? object_or_sash.sash : object_or_sash
+    unless sash.badges.include? self
+      sash.badges << self
+      sash.save
+    end
+  end
+
+  # Take out badge from sash
+  def delete_from(object_or_sash)
+    object_or_sash.create_sash_if_none unless object_or_sash.kind_of?(Sash)
+    sash = object_or_sash.respond_to?(:sash) ? object_or_sash.sash : object_or_sash
+    if sash.badges.include? self
+      sash.badges -= [self]
+      sash.save
+    end
+  end
+
+  # Give rank to sash if it's greater. Delete lower ranks it may have.
+  def grant_rank_to(sash)
+    # Grant to sash if had lower rank. Do nothing if has same or greater rank.
+    if sash.has_lower_rank_than(self)
+      sash.badges -= Badge.where(:name => name) # Clean up old ranks
+      sash.badges << self
+      sash.save
+    end
+  end
+
+  def self.latest(limit = nil)
+    scope = order('created_at DESC')
+    limit.present? ? scope.limit(limit) : scope
+  end
+end

data/app/models/badges_sash.rb

@@ -0,0 +1,14 @@
+class BadgesSash < ActiveRecord::Base
+  belongs_to :badge
+  belongs_to :sash
+
+  # TODO: Better way to do it? With composite keys ARel complained:
+  # NoMethodError: undefined method `eq' for nil:NilClass
+  #  from ~/.rvm/gems/ruby-1.9.2-p0/gems/activesupport-3.0.9/lib/active_support/whiny_nil.rb:48:in `method_missing'
+  #  from ~/.rvm/gems/ruby-1.9.2-p0/gems/activerecord-3.0.9/lib/active_record/persistence.rb:259:in `update'
+  def set_notified!(badge, sash)
+    ActiveRecord::Base.connection.execute("UPDATE badges_sashes
+      SET notified_user = TRUE
+      WHERE badge_id = #{badge.id} AND sash_id = #{sash.id}")
+  end
+end

data/app/models/merit_action.rb

@@ -0,0 +1,48 @@
+class MeritAction < ActiveRecord::Base
+  # Check rules defined for a merit_action
+  def check_badge_rules(defined_rules)
+    action_name = "#{target_model}\##{action_method}"
+
+    # Check Badge rules
+    if defined_rules[action_name].present?
+      defined_rules[action_name].each do |rule|
+        rule.grant_or_delete_badge(self)
+      end
+    end
+
+    # Check Point rules
+    actions_to_point = MeritPointRules.new.actions_to_point
+    if actions_to_point[action_name].present?
+      point_rule = actions_to_point[action_name]
+      point_rule[:to].each do |to|
+        if to == :action_user
+          if !(target = User.find_by_id(user_id))
+            Rails.logger.warn "[merit] no user found to grant points"
+            return
+          end
+        else
+          begin
+            target = target_object.send(to)
+          rescue
+            Rails.logger.warn "[merit] No target_object found on check_badge_rules."
+            return
+          end
+        end
+        target.update_attribute(:points, target.points + point_rule[:score])
+      end
+    end
+
+    processed!
+  end
+
+  # Action's target object
+  def target_object
+    klass = target_model.singularize.camelize.constantize
+    klass.find_by_id(target_id)
+  end
+
+  # Mark merit_action as processed
+  def processed!
+    self.update_attribute(:processed, true)
+  end
+end

data/app/models/sash.rb

@@ -0,0 +1,19 @@
+class Sash < ActiveRecord::Base
+  has_many :badges_sashes
+  has_many :badges, :through => :badges_sashes
+
+  # Latest badges granted by Merit
+  def self.latest_badges(limit = 10)
+    select('DISTINCT sashes.id, sashes.*').joins(:badges_sashes).order('badges_sashes.created_at DESC').limit(limit)
+  end
+
+  # Decides if sash has lower rank than a given badge
+  def has_lower_rank_than(badge)
+    levels(badge.name).all_lower_than badge.level
+  end
+
+  # Collect Sash levels given a badge name
+  def levels(badge_name)
+    badges.where(:name => badge_name).collect(&:level)
+  end
+end

data/lib/generators/active_record/merit_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class MeritGenerator < ActiveRecord::Generators::Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+
+      def copy_merit_migration
+        migration_template "add_fields_to_model.rb", "db/migrate/add_fields_to_#{table_name}"
+      end
+
+      def inject_merit_content
+        inject_into_class(model_path, class_name, "  has_merit\n\n") if model_exists?
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/add_fields_to_model.rb

@@ -0,0 +1,13 @@
+class AddFieldsTo<%= table_name.camelize %> < ActiveRecord::Migration
+  def self.up
+    add_column :<%= table_name %>, :sash_id, :integer
+    add_column :<%= table_name %>, :points, :integer, :default => 0
+    <%- resource = table_name.singularize -%>
+    <%= resource.camelize %>.all.each{|<%= resource %>| <%= resource %>.update_attribute(:points, 0) } # Update existing entries
+  end
+
+  def self.down
+    remove_column :<%= table_name %>, :sash_id
+    remove_column :<%= table_name %>, :points
+  end
+end

data/lib/generators/merit/install_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators/migration'
+
+module Merit
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      desc "add the migrations"
+
+      def self.next_migration_number(path)
+        unless @prev_migration_nr
+          @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        else
+          @prev_migration_nr += 1
+        end
+        @prev_migration_nr.to_s
+      end
+
+      def copy_migrations_and_model
+        migration_template 'create_merit_actions.rb', 'db/migrate/create_merit_actions.rb'
+        migration_template 'create_badges.rb', 'db/migrate/create_badges.rb'
+        migration_template 'create_sashes.rb', 'db/migrate/create_sashes.rb'
+        migration_template 'create_badges_sashes.rb', 'db/migrate/create_badges_sashes.rb'
+        template 'merit_badge_rules.rb', 'app/models/merit_badge_rules.rb'
+        template 'merit_point_rules.rb', 'app/models/merit_point_rules.rb'
+        template 'merit_rank_rules.rb', 'app/models/merit_rank_rules.rb'
+        template 'merit.rb', 'config/initializers/merit.rb'
+      end
+    end
+  end
+end

data/lib/generators/merit/merit_generator.rb

@@ -0,0 +1,8 @@
+module Merit
+  module Generators
+    class MeritGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+      hook_for :orm
+    end
+  end
+end

data/lib/generators/merit/templates/create_badges.rb

@@ -0,0 +1,19 @@
+class CreateBadges < ActiveRecord::Migration
+  def self.up
+    create_table :badges do |t|
+      t.string :name
+      t.string :level
+      t.string :image
+      t.string :description
+      t.timestamps
+    end
+
+    # First badges:
+    # Badge.create( :name => 'just-registered' )
+    # Badge.create( :name => 'creator', :level => 'inspired', :image => 'http://upload.wikimedia.org/wikipedia/commons/9/94/Luca_prodan.jpg' )
+  end
+
+  def self.down
+    drop_table :badges
+  end
+end

data/lib/generators/merit/templates/create_badges_sashes.rb

@@ -0,0 +1,16 @@
+class CreateBadgesSashes < ActiveRecord::Migration
+  def self.up
+    create_table :badges_sashes, :id => false do |t|
+      t.integer :badge_id, :sash_id
+      t.boolean :notified_user, :default => false
+      t.datetime :created_at
+    end
+    add_index :badges_sashes, [:badge_id, :sash_id]
+    add_index :badges_sashes, :badge_id
+    add_index :badges_sashes, :sash_id
+  end
+
+  def self.down
+    drop_table :badges_sashes
+  end
+end

data/lib/generators/merit/templates/create_merit_actions.rb

@@ -0,0 +1,17 @@
+class CreateMeritActions < ActiveRecord::Migration
+  def self.up
+    create_table :merit_actions do |t|
+      t.integer :user_id # source
+      t.string  :action_method
+      t.integer :action_value
+      t.string  :target_model
+      t.integer :target_id
+      t.boolean :processed, :default => false
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :merit_actions
+  end
+end

data/lib/generators/merit/templates/create_sashes.rb

@@ -0,0 +1,11 @@
+class CreateSashes < ActiveRecord::Migration
+  def self.up
+    create_table :sashes do |t|
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :sashes
+  end
+end

data/lib/generators/merit/templates/merit.rb

@@ -0,0 +1,5 @@
+# Use this hook to configure merit parameters
+Merit.setup do |config|
+  # Check rules on each request or in background
+  # config.checks_on_each_request = true
+end

data/lib/generators/merit/templates/merit_badge_rules.rb

@@ -0,0 +1,40 @@
+# +grant_on+ accepts:
+# * Nothing (always grants)
+# * A block which evaluates to boolean (recieves the object as parameter)
+# * A block with a hash composed of methods to run on the target object with
+#   expected values (+:votes => 5+ for instance).
+#
+# +grant_on+ can have a +:to+ method name, which called over the target object
+# should retrieve the object to badge (could be +:user+, +:self+, +:follower+,
+# etc). If it's not defined merit will apply the badge to the user who
+# triggered the action (:action_user by default). If it's :itself, it badges
+# the created object (new user for instance).
+#
+# The :temporary option indicates that if the condition doesn't hold but the
+# badge is granted, then it's removed. It's false by default (badges are kept
+# forever).
+
+class MeritBadgeRules
+  include Merit::BadgeRules
+
+  def initialize
+    # If it creates user, grant badge
+    # Should be "current_user" after registration for badge to be granted.
+    # grant_on 'users#create', :badge => 'just-registered', :to => :itself
+
+    # If it has 10 comments, grant commenter-10 badge
+    # grant_on 'comments#create', :badge => 'commenter', :level => 10 do
+    #   { :user => { :comments => { :count => 10 } } }
+    # end
+
+    # If it has 5 votes, grant relevant-commenter badge
+    # grant_on 'comments#vote', :badge => 'relevant-commenter', :to => :user do
+    #   { :votes => 5 }
+    # end
+
+    # Changes his name by one wider than 4 chars (arbitrary ruby code case)
+    # grant_on 'users#update', :badge => 'autobiographer', :temporary => true do |user|
+    #   user.name.length > 4
+    # end
+  end
+end

data/lib/generators/merit/templates/merit_point_rules.rb

@@ -0,0 +1,21 @@
+# Points are a simple integer value which are given to "meritable" resources
+# according to rules in +app/models/merit_point_rules.rb+. They are given on
+# actions-triggered, either to the action user or to the method (or array of
+# methods) defined in the +:to+ option.
+
+class MeritPointRules
+  include Merit::PointRules
+
+  def initialize
+    # score 10, :on => [
+    #   'users#update'
+    # ]
+    #
+    # score 15, :on => 'reviews#create', :to => [:reviewer, :reviewed]
+    #
+    # score 20, :on => [
+    #   'comments#create',
+    #   'photos#create'
+    # ]
+  end
+end

data/lib/generators/merit/templates/merit_rank_rules.rb

@@ -0,0 +1,30 @@
+# Rankings are very similar to badges. They give "badges" which have a hierarchy
+# defined by +level+'s lexicografical order (greater is better). If a rank is
+# granted, lower level ranks are taken off. 5 stars is a common ranking use
+# case.
+#
+# They are not given at specified actions like badges, you should define a cron
+# job to test if ranks are to be granted.
+#
+# +set_rank+ accepts:
+# * +badge_name+ name of this ranking
+# * :+level+ ranking level (greater is better)
+# * :+to+ model or scope to check if new rankings apply
+
+class MeritRankRules
+  include Merit::RankRules
+
+  def initialize
+    # set_rank :stars, :level => 1, :to => Commiter.active do |commiter|
+    #   commiter.repositories.count > 1 && commiter.followers >= 10
+    # end
+    #
+    # set_rank :stars, :level => 2, :to => Commiter.active do |commiter|
+    #   commiter.branches.count > 1 && commiter.followers >= 10
+    # end
+    #
+    # set_rank :stars, :level => 3, :to => Commiter.active do |commiter|
+    #   commiter.branches.count > 2 && commiter.followers >= 20
+    # end
+  end
+end

data/lib/merit.rb

@@ -0,0 +1,26 @@
+require 'merit/core_extensions'
+require 'merit/rule'
+require 'merit/rules_badge'
+require 'merit/rules_points'
+require 'merit/rules_rank'
+require 'merit/controller_extensions'
+require 'merit/model_additions'
+
+module Merit
+  # Check rules on each request
+  mattr_accessor :checks_on_each_request
+  @@checks_on_each_request = true
+
+  # Load configuration from initializer
+  def self.setup
+    yield self
+  end
+
+  class Engine < Rails::Engine
+    initializer 'merit.controller' do |app|
+      ActiveSupport.on_load(:action_controller) do
+         include Merit::ControllerExtensions
+      end
+    end
+  end
+end

data/lib/merit/controller_extensions.rb

@@ -0,0 +1,36 @@
+module Merit
+  # This module sets up an after_filter to update merit_actions table.
+  # It executes on every action, and checks rules only if
+  # 'controller_name#action_name' has defined badge or point rules
+  module ControllerExtensions
+    def self.included(base)
+      base.after_filter do |controller|
+        action      = "#{controller_name}\##{action_name}"
+        badge_rules = ::MeritBadgeRules.new
+        point_rules = ::MeritPointRules.new
+        if badge_rules.defined_rules[action].present? || point_rules.actions_to_point[action].present?
+          target_id = params[:id]
+          # TODO: target_object should be configurable (now it's singularized controller name)
+          unless target_id =~ /^[0-9]+$/ # id nil, or string (friendly_id)?
+            target_id = instance_variable_get(:"@#{controller_name.singularize}").try(:id)
+          end
+
+          # TODO: value relies on params[:value] on the controller, should be configurable
+          value = params[:value]
+          MeritAction.create(
+            :user_id       => current_user.try(:id),
+            :action_method => action_name,
+            :action_value  => value,
+            :target_model  => controller_name,
+            :target_id     => target_id
+          )
+
+          # Check rules in after_filter?
+          if Merit.checks_on_each_request
+            ::MeritBadgeRules.new.check_new_actions
+          end
+        end
+      end
+    end
+  end
+end

data/lib/merit/core_extensions.rb

@@ -0,0 +1,28 @@
+# Hash core extensions:
+#   * conditions_apply?(obj)
+class Hash
+  # Methods over object (applied recursively) respond what's expected?
+  # Example (evaluates to true):
+  #   { :first => { :odd? => true }, :count => 2 }.conditions_apply? [1,3]
+  def conditions_apply?(obj)
+    applies = true
+    self.each do |method, value|
+      called_obj = obj.send(method)
+      if value.kind_of?(Hash)
+        applies = applies && value.conditions_apply?(called_obj)
+      else
+        applies = applies && called_obj == value
+      end
+    end
+    applies
+  end
+end
+
+# Array core extensions:
+#   * all_lower_than(value)
+class Array
+  # All array values are lower than parameter
+  def all_lower_than(value)
+    self.select{|elem| elem >= value }.empty?
+  end
+end

data/lib/merit/model_additions.rb

@@ -0,0 +1,30 @@
+module Merit
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    def has_merit(options = {})
+      belongs_to :sash
+      send :include, InstanceMethods
+    end
+  end
+
+  module InstanceMethods
+    # Return it's sash badges
+    def badges
+      create_sash_if_none
+      sash.badges
+    end
+
+    # Create sash if doesn't have
+    def create_sash_if_none
+      if sash.nil?
+        self.sash = Sash.new
+        self.save(:validate => false)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Merit

data/lib/merit/railtie.rb

@@ -0,0 +1,7 @@
+require 'merit'
+require 'rails'
+
+module Merit
+  class Engine < Rails::Engine
+  end
+end

data/lib/merit/rule.rb

@@ -0,0 +1,82 @@
+module Merit
+  # Rules has a badge name and level, a target to badge, a conditions block
+  # and a temporary option.
+  class Rule
+    attr_accessor :badge_name, :level, :to, :temporary, :block
+
+    # Does this rule's condition block apply?
+    def applies?(target_obj = nil)
+      # no block given: always true
+      no_block_or_true = true
+      unless block.nil?
+        case block.parameters.count
+        when 1
+          # block expects parameter: pass target_object
+          if target_obj.nil?
+            no_block_or_true = false
+            Rails.logger.warn "[merit] no target_obj found on Rule#applies?"
+          else
+            no_block_or_true = block.call(target_obj)
+          end
+
+        when 0
+          # block evaluates to true, or is a hash of methods and expected value
+          called = block.call
+          if called.kind_of?(Hash)
+            no_block_or_true = called.conditions_apply? target_obj
+          end
+
+        end
+      end
+      no_block_or_true
+    end
+
+    # Is this rule's badge temporary?
+    def temporary?; self.temporary; end
+
+    # Grant badge if rule applies. If it doesn't, and the badge is temporary,
+    # then remove it.
+    def grant_or_delete_badge(action)
+      if sash = sash_to_badge(action)
+        if applies? action.target_object
+          badge.grant_to sash
+        elsif temporary?
+          badge.delete_from sash
+        end
+      else
+        Rails.logger.warn "[merit] no sash found on Rule#grant_or_delete_badge"
+      end
+    end
+
+    # Subject to badge: source_user or target.user?
+    def sash_to_badge(action)
+      target = case to
+               when :action_user
+                 User.find_by_id(action.user_id) # _by_id doens't raise ActiveRecord::RecordNotFound
+               when :itself
+                 action.target_object
+               else
+                 begin
+                   action.target_object.send(to)
+                 rescue
+                   Rails.logger.warn "[merit] #{action.target_model.singularize}.find(#{action.target_id}) not found, no badges giving today"
+                   return
+                 end
+               end
+      if target
+        target.create_sash_if_none
+        target.sash
+      end
+    end
+
+    # Get rule's related Badge.
+    def badge
+      if @badge.nil?
+        badges = Badge.where(:name => badge_name)
+        badges = badges.where(:level => level.to_s) unless level.nil?
+        @badge = badges.first
+      end
+      @badge
+    end
+  end
+end

data/lib/merit/rules_badge.rb

@@ -0,0 +1,64 @@
+module Merit
+  # La configuración para especificar cuándo aplicar cada badge va en
+  # app/models/merit_rules.rb, con la siguiente sintaxis:
+  #
+  #   grant_on 'users#create', :badge => 'just', :level => 'registered' do
+  #     # Nothing, or code block which evaluates to true
+  #     # or with a { methods -> expected_values } hash.
+  #   end
+  #
+  # También se puede asignar medallas desde métodos en controladores:
+  #
+  #   Badge.find(3).grant_to(current_user)
+  #
+  # Merit crea una tabla Badges similar a:
+  #   ___________________________________________________
+  #   id | name    | level       | image
+  #   1  | creador | inspirado   | creador-inspirado.png
+  #   2  | creador | blogger     | creador-blogger.png
+  #   2  | creador | best-seller | creador-bestseller.png
+  #   ___________________________________________________
+  #
+  # Y llena una tabla de acciones, del estilo de:
+  #   ______________________________________________________________
+  #   source (user_id) | action (method, value) | target (model, id) | processed
+  #   1 | comment nil | List 8 | true
+  #   1 | vote 3      | List 12 | true
+  #   3 | follow nil  | User 1 | false
+  #   X | create nil  | User #{generated_id} | false
+  #   ______________________________________________________________
+  #
+  # Luego chequea las condiciones sincronizadamente, o mediante un proceso en
+  # background, por ejemplo cada 5 minutos (Merit::BadgeRules#check_new_actions).
+  module BadgeRules
+    # Define rule for granting badges
+    def grant_on(action, *args, &block)
+      options = args.extract_options!
+
+      rule = Rule.new
+      rule.badge_name = options[:badge]
+      rule.level      = options[:level]
+      rule.to         = options[:to] || :action_user
+      rule.temporary  = options[:temporary] || false
+      rule.block      = block
+
+      actions = action.kind_of?(String) ? [action] : action
+      actions.each do |action|
+        defined_rules[action] ||= []
+        defined_rules[action] << rule
+      end
+    end
+
+    # Check non processed actions and grant badges if applies
+    def check_new_actions
+      MeritAction.where(:processed => false).each do |merit_action|
+        merit_action.check_badge_rules(defined_rules)
+      end
+    end
+
+    # Currently defined rules
+    def defined_rules
+      @defined_rules ||= {}
+    end
+  end
+end

data/lib/merit/rules_points.rb

@@ -0,0 +1,23 @@
+module Merit
+  # Points are a simple integer value which are given to "meritable" resources
+  # according to rules in +app/models/merit_point_rules.rb+. They are given on
+  # actions-triggered.
+  module PointRules
+    # Define rules on certaing actions for giving points
+    def score(points, *args, &block)
+      options = args.extract_options!
+
+      actions = options[:on].kind_of?(Array) ? options[:on] : [options[:on]]
+      options[:to] ||= [:action_user]
+      targets = options[:to].kind_of?(Array) ? options[:to] : [options[:to]]
+      actions.each do |action|
+        actions_to_point[action] = { to: targets, score: points }
+      end
+    end
+
+    # Currently defined rules
+    def actions_to_point
+      @actions_to_point ||= {}
+    end
+  end
+end

data/lib/merit/rules_rank.rb

@@ -0,0 +1,54 @@
+module Merit
+  # Rankings are very similar to badges. They give "badges" which have a hierarchy
+  # defined by +level+'s lexicografical order (greater is better). If a rank is
+  # granted, lower level ranks are taken off. 5 stars is a common ranking use
+  # case.
+  #
+  # They are not given at specified actions like badges, you should define a cron
+  # job to test if ranks are to be granted.
+  #
+  # +set_rank+ accepts:
+  # * +badge_name+ name of this ranking
+  # * :+level+ ranking level (greater is better)
+  # * :+to+ model or scope to check if new rankings apply
+  module RankRules
+    # Populates +defined_rules+ hash with following hierarchy:
+    #   defined_rules[ModelToRank][rankings] = [level, conditions_block]
+    def set_rank(ranking, *args, &block)
+      options = args.extract_options!
+
+      rule = Rule.new
+      rule.badge_name = ranking
+      rule.level      = options[:level]
+      rule.block      = block
+
+      defined_rules[options[:to]] ||= {}
+      defined_rules[options[:to]][ranking] ||= []
+      defined_rules[options[:to]][ranking] << rule
+    end
+
+    # Check rules defined for a merit_action
+    def check_rank_rules
+      defined_rules.each do |scoped_model, rankings| # For each model
+        rankings.each do |ranking, rules| # For each model's ranking (stars, etc)
+          rules.each do |rule|            # For each ranking's rule (level)
+            scoped_model.all.each {|obj| grant_rank(rule, obj) }
+          end
+        end
+      end
+    end
+
+    # Grant rank if rule applies
+    # Badge checks if it's rank is greater than sash's current one.
+    def grant_rank(rule, target_object)
+      if rule.applies? target_object
+        rule.badge.grant_rank_to target_object.sash
+      end
+    end
+
+    # Currently defined rules
+    def defined_rules
+      @defined_rules ||= {}
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: merit
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+  prerelease: 
+platform: ruby
+authors:
+- Tute Costa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-25 00:00:00.000000000 Z
+dependencies: []
+description: General reputation Rails engine.
+email: tutecosta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/models/badge.rb
+- app/models/merit_action.rb
+- app/models/badges_sash.rb
+- app/models/sash.rb
+- lib/merit/rules_points.rb
+- lib/merit/rule.rb
+- lib/merit/railtie.rb
+- lib/merit/core_extensions.rb
+- lib/merit/model_additions.rb
+- lib/merit/rules_rank.rb
+- lib/merit/controller_extensions.rb
+- lib/merit/rules_badge.rb
+- lib/merit.rb
+- lib/generators/merit/templates/merit_rank_rules.rb
+- lib/generators/merit/templates/create_merit_actions.rb
+- lib/generators/merit/templates/merit_point_rules.rb
+- lib/generators/merit/templates/create_sashes.rb
+- lib/generators/merit/templates/merit.rb
+- lib/generators/merit/templates/create_badges.rb
+- lib/generators/merit/templates/create_badges_sashes.rb
+- lib/generators/merit/templates/merit_badge_rules.rb
+- lib/generators/merit/merit_generator.rb
+- lib/generators/merit/install_generator.rb
+- lib/generators/active_record/templates/add_fields_to_model.rb
+- lib/generators/active_record/merit_generator.rb
+- MIT-LICENSE
+- Rakefile
+- Gemfile
+- README.rdoc
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: General reputation Rails engine.
+test_files: []