merit 1.1.0 → 1.1.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    merit (1.1.0)
+    merit (1.1.1)
       ambry (~> 0.3.0)
 
 GEM

data/README.md

@@ -148,11 +148,7 @@ end
 
 # To-do list
 
-* `Merit::BadgeRules.new.defined_rules` should be cached on initialization,
-  instead of initialized per controllers `after_filter` and
-  `merit_action.check_rules`.
 * target_object should be configurable (now it's singularized controller name)
-* Translate comments from spanish in `rules_badge.rb`.
 * Should namespace app/models into Merit module.
 * :value parameter (for star voting for example) should be configurable
   (depends on params[:value] on the controller).

data/app/models/badge.rb

@@ -23,6 +23,15 @@ class Badge
     end
   end
 
+  def self.find_by_name_and_level(name, level)
+    badges = Badge.by_name(name)
+    badges = badges.by_level(level) unless level.nil?
+    if !(badge = badges.first)
+      raise ::Merit::BadgeNotFound, "No badge '#{name}'#{level.nil? ? '' : " with level #{level}"} found. Define it in 'config/initializers/merit.rb'."
+    end
+    badge
+  end
+
   # Grant badge to sash
   # Accepts :allow_multiple boolean option, defaults to false
   def grant_to(object_or_sash, *args)
@@ -49,11 +58,13 @@ class Badge
     end
   end
 
+  private
+
   def sash_from(object_or_sash)
     if object_or_sash.kind_of?(Sash)
       object_or_sash
     else
-      object_or_sash.sash || object_or_sash.create_sash_and_scores
+      object_or_sash._sash
     end
   end
 end

data/app/models/merit_action.rb

@@ -1,9 +1,25 @@
 require "merit/models/#{Merit.orm}/merit_action"
 
+# MeritAction general schema
+#   ______________________________________________________________
+#   source  | action       | target
+#   user_id | method,value | 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
+#   ______________________________________________________________
+#
+# Rules relate to merit_actions by action name ('controller#action' string)
 class MeritAction
   attr_accessible :user_id, :action_method, :action_value, :had_errors,
     :target_model, :target_id, :processed, :log
 
+  def self.check_unprocessed_rules
+    where(:processed => false).map &:check_rules
+  end
+
   # Check rules defined for a merit_action
   def check_rules
     unless had_errors
@@ -13,24 +29,38 @@ class MeritAction
     processed!
   end
 
+  def target(to)
+    @target ||= (to == :action_user) ? action_user : other_target(to)
+  end
+
+  def target_object(model_name = nil)
+    # Grab custom model_name from Rule, or target_model from MeritAction triggered
+    klass = model_name || target_model
+    klass.singularize.camelize.constantize.find_by_id(target_id)
+  rescue => e
+    Rails.logger.warn "[merit] no target_object found: #{e}"
+  end
+
+  def log_activity(str)
+    self.update_attribute :log, "#{self.log}#{str}|"
+  end
+
+  private
+
   def check_badge_rules
-    badge_rules = Merit::BadgeRules.new.defined_rules[action_str] || []
-    badge_rules.each { |rule| rule.grant_or_delete_badge(self) }
+    rules = AppBadgeRules[action_str] || []
+    rules.each { |rule| rule.apply_badges(self) }
   end
 
   def check_point_rules
-    point_rules = Merit::PointRules.new.defined_rules[action_str] || []
-    point_rules.each { |rule| rule.grant_points(self) }
+    rules = AppPointRules[action_str] || []
+    rules.each { |rule| rule.apply_points(self) }
   end
 
   def action_str
     "#{target_model}\##{action_method}"
   end
 
-  def target(to)
-    @target ||= (to == :action_user) ? action_user : other_target(to)
-  end
-
   def action_user
     begin
       Merit.user_model.find(user_id)
@@ -49,20 +79,6 @@ class MeritAction
     end
   end
 
-  # Action's target object
-  def target_object(model_name = nil)
-    # Grab custom model_name from Rule, or target_model from MeritAction triggered
-    klass = model_name || target_model
-    klass.singularize.camelize.constantize.find_by_id(target_id)
-  rescue => e
-    Rails.logger.warn "[merit] no target_object found: #{e}"
-  end
-
-  def log!(str)
-    self.log = "#{self.log}#{str}|"
-    self.save
-  end
-
   # Mark merit_action as processed
   def processed!
     self.processed = true

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

@@ -4,7 +4,7 @@ class CreateMeritActions < ActiveRecord::Migration
       t.integer :user_id # source
       t.string  :action_method
       t.integer :action_value
-      t.boolean :had_errors
+      t.boolean :had_errors, :default => false
       t.string  :target_model
       t.integer :target_id
       t.boolean :processed, :default => false

data/lib/merit.rb

@@ -1,7 +1,7 @@
 require 'merit/rule'
-require 'merit/rules_badge'
-require 'merit/rules_points'
-require 'merit/rules_rank'
+require 'merit/rules_badge_methods'
+require 'merit/rules_points_methods'
+require 'merit/rules_rank_methods'
 require 'merit/controller_extensions'
 require 'merit/model_additions'
 
@@ -48,6 +48,10 @@ module Merit
       end
 
       ActiveSupport.on_load(:action_controller) do
+        # Load application defined rules
+        ::Merit::AppBadgeRules = BadgeRules.new.defined_rules
+        ::Merit::AppPointRules = PointRules.new.defined_rules
+
         include Merit::ControllerExtensions
       end
     end

data/lib/merit/controller_extensions.rb

@@ -1,31 +1,38 @@
 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
+  # Sets up an app-wide after_filter, and inserts merit_action entries if
+  # there are defined rules (for badges or points) for current
+  # 'controller_name#action_name'
   module ControllerExtensions
     def self.included(base)
       base.after_filter do |controller|
-        action      = "#{controller_name}\##{action_name}"
-        badge_rules = BadgeRules.new
-        point_rules = PointRules.new
-        if badge_rules.defined_rules[action].present? || point_rules.defined_rules[action].present?
-          merit_action_id = MeritAction.create(
-            :user_id       => send(Merit.current_user_method).try(:id),
-            :action_method => action_name,
-            :action_value  => params[:value],
-            :had_errors    => target_object.try(:errors).try(:present?) || false,
-            :target_model  => controller_name,
-            :target_id     => target_id
-          ).id
+        return unless rules_defined?
 
-          # Check rules in after_filter?
-          if Merit.checks_on_each_request
-            badge_rules.check_new_actions
-          end
+        MeritAction.create(
+          :user_id       => send(Merit.current_user_method).try(:id),
+          :action_method => action_name,
+          :action_value  => params[:value],
+          :had_errors    => had_errors?,
+          :target_model  => controller_name,
+          :target_id     => target_id
+        ).id
+
+        if Merit.checks_on_each_request
+          MeritAction.check_unprocessed_rules
         end
       end
     end
 
+    private
+
+    def rules_defined?
+      action = "#{controller_name}\##{action_name}"
+      AppBadgeRules[action].present? || AppPointRules[action].present?
+    end
+
+    def had_errors?
+      target_object.try(:errors).try(:present?) || false
+    end
+
     def target_object
       target_obj = instance_variable_get(:"@#{controller_name.singularize}")
       if target_obj.nil?
@@ -36,7 +43,7 @@ module Merit
 
     def target_id
       target_id = params[:id] || target_object.try(:id)
-      # using friendly_id if id nil or string (), and target_object found
+      # using friendly_id if id is nil or string but an object was found
       if target_object.present? && (target_id.nil? || !(target_id =~ /^[0-9]+$/))
         target_id = target_object.id
       end

data/lib/merit/model_additions.rb

@@ -3,8 +3,9 @@ module Merit
 
   module ClassMethods
     def has_merit(options = {})
-      # :dependent => destroy may raise
-      # ERROR: update or delete on table "sashes" violates foreign key constraint "users_sash_id_fk"
+      # MeritableModel#sash_id is more stable than Sash#meritable_model_id
+      # That's why MeritableModel belongs_to Sash. Can't use
+      # :dependent => destroy as it may raise FK constraint exceptions. See:
       # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/1079-belongs_to-dependent-destroy-should-destroy-self-before-assocation
       belongs_to :sash
 
@@ -22,31 +23,17 @@ module Merit
         end
       end
 
-      # Add instance methods to meritable models
-      # Using define_method on meritable classes to not pollute every model
-
       # Delegate relationship methods from meritable models to their sash
-      %w(badge_ids badges points).each do |method|
-        define_method(method) do
-          _sash = sash || create_sash_and_scores
-          _sash.send method
-        end
-      end
-
-      define_method(:add_points) do |num_points, log = 'Manually through `add_points`', category = 'default'|
-        _sash = sash || create_sash_and_scores
-        _sash.add_points num_points, log, category
-      end
-      define_method(:substract_points) do |num_points, log = 'Manually through `substract_points`', category = 'default'|
-        _sash = sash || create_sash_and_scores
-        _sash.substract_points num_points, log, category
+      # _sash initializes a sash if doesn't have one yet.
+      # From Rails 3.2 we can override association methods to do so
+      # transparently, but merit supports Rails ~> 3.0.0. See:
+      # http://blog.hasmanythrough.com/2012/1/20/modularized-association-methods-in-rails-3-2
+      %w(badge_ids badges points add_points substract_points).each do |method|
+        delegate method, to: :_sash
       end
-
-      # Create sash if doesn't have
-      define_method(:create_sash_and_scores) do
-        if self.sash.blank?
+      define_method(:_sash) do
+        if sash.nil?
           self.sash = Sash.create
-          self.sash.scores << Merit::Score.create
           self.save(:validate => false)
         end
         self.sash

data/lib/merit/models/active_record/merit/score.rb

@@ -9,7 +9,6 @@ module Merit
     end
 
     class Point < ActiveRecord::Base
-      self.table_name = :merit_score_points
       belongs_to :score, :class_name => 'Merit::Score'
     end
   end

data/lib/merit/models/active_record/sash.rb

@@ -1,7 +1,15 @@
+# Sash is a container for reputation data for meritable models. It's an
+# indirection between meritable models and badges and scores (one to one
+# relationship).
+#
+# It's existence make join models like badges_users and scores_users
+# unnecessary. It should be transparent at the application.
 class Sash < ActiveRecord::Base
   has_many :badges_sashes, :dependent => :destroy
   has_many :scores, :dependent => :destroy, :class_name => 'Merit::Score'
 
+  after_create :create_scores
+
   def badges
     badge_ids.collect { |b_id| Badge.find(b_id) }
   end
@@ -33,4 +41,10 @@ class Sash < ActiveRecord::Base
   def substract_points(num_points, log = 'Manually granted through `add_points`', category = 'default')
     add_points -num_points, log, category
   end
+
+  private
+
+  def create_scores
+    self.scores << Merit::Score.create
+  end
 end

data/lib/merit/rule.rb

@@ -28,25 +28,25 @@ module Merit
 
     # Grant badge if rule applies. If it doesn't, and the badge is temporary,
     # then remove it.
-    def grant_or_delete_badge(action)
+    def apply_badges(action)
       unless (sash = sash_to_badge(action))
-        Rails.logger.warn "[merit] no sash found on Rule#grant_or_delete_badge for action #{action.inspect}"
+        Rails.logger.warn "[merit] no sash found on Rule#apply_badges for action #{action.inspect}"
         return
       end
 
       if applies? action.target_object(model_name)
         if badge.grant_to(sash, :allow_multiple => self.multiple)
           to_action_user = (to.to_sym == :action_user ? '_to_action_user' : '')
-          action.log!("badge_granted#{to_action_user}:#{badge.id}")
+          action.log_activity "badge_granted#{to_action_user}:#{badge.id}"
         end
       elsif temporary?
         if badge.delete_from(sash)
-          action.log!("badge_removed:#{badge.id}")
+          action.log_activity "badge_removed:#{badge.id}"
         end
       end
     end
 
-    def grant_points(action)
+    def apply_points(action)
       unless (sash = sash_to_badge(action))
         Rails.logger.warn "[merit] no sash found on Rule#grant_points"
         return
@@ -54,7 +54,7 @@ module Merit
 
       if applies? action.target_object(model_name)
         sash.add_points self.score, action.inspect[0..240]
-        action.log!("points_granted:#{self.score}")
+        action.log_activity "points_granted:#{self.score}"
       end
     end
 
@@ -68,21 +68,12 @@ module Merit
       else
         target = action.target(to)
       end
-      if target
-        target.sash || target.create_sash_and_scores
-      end
+      target._sash if target
     end
 
     # Get rule's related Badge.
     def badge
-      if @badge.nil?
-        badges = Badge.by_name(badge_name)
-        badges = badges.by_level(level) unless level.nil?
-        if !(@badge = badges.first)
-          raise BadgeNotFound, "No badge '#{badge_name}'#{level.nil? ? '' : " with level #level"} found. Define it in 'config/initializers/merit.rb'."
-        end
-      end
-      @badge
+      @badge ||= Badge.find_by_name_and_level(badge_name, level)
     end
   end
 end

data/lib/merit/rules_badge_methods.rb

@@ -0,0 +1,29 @@
+module Merit
+  module BadgeRulesMethods
+    # Define rule for granting badges
+    def grant_on(action, *args, &block)
+      options = args.extract_options!
+
+      actions = Array.wrap(action)
+
+      rule = Rule.new
+      rule.badge_name = options[:badge]
+      rule.level      = options[:level]
+      rule.to         = options[:to] || :action_user
+      rule.multiple   = options[:multiple] || false
+      rule.temporary  = options[:temporary] || false
+      rule.model_name = options[:model_name] || actions[0].split('#')[0]
+      rule.block      = block
+
+      actions.each do |action|
+        defined_rules[action] ||= []
+        defined_rules[action] << rule
+      end
+    end
+
+    # Currently defined rules
+    def defined_rules
+      @defined_rules ||= {}
+    end
+  end
+end

data/lib/merit/{rules_rank.rb → rules_rank_methods.rb}

@@ -22,7 +22,8 @@ module Merit
       defined_rules[options[:to]].merge!({ options[:level] => rule })
     end
 
-    # Check rules defined for a merit_action
+    # Not part of merit after_filter. To be called asynchronously:
+    # Merit::RankRules.new.check_rank_rules
     def check_rank_rules
       defined_rules.each do |scoped_model, level_and_rules|
         level_and_rules = level_and_rules.sort

data/merit.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |s|
   s.description = "Manage badges, points and rankings (reputation) of resources in a Rails application."
   s.homepage    = "http://github.com/tute/merit"
   s.files       = `git ls-files`.split("\n").reject{|f| f =~ /^\./ }
-  s.version     = '1.1.0'
+  s.version     = '1.1.1'
   s.authors     = ["Tute Costa"]
   s.email       = 'tutecosta@gmail.com'
   s.add_dependency 'ambry',  '~> 0.3.0'

data/test/merit_unit_test.rb

@@ -45,12 +45,6 @@ class MeritUnitTest < ActiveSupport::TestCase
     assert badge_sash.notified_user
   end
 
-  # TODO: Test and refactor:
-  # Rule: grant_or_delete_badge(action), sash_to_badge
-  # Badge: delete_from
-  # MeritAction: target(to), action_user, other_target(to), target_object(model_name = nil)
-
-
   test "Badge#grant_to allow_multiple option" do
     badge = Badge.create(:id => 99, :name => 'test-badge')
     sash = Sash.create(:id => 99)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: merit
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-24 00:00:00.000000000 Z
+date: 2012-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ambry
@@ -180,9 +180,9 @@ files:
 - lib/merit/models/mongoid/merit_action.rb
 - lib/merit/models/mongoid/sash.rb
 - lib/merit/rule.rb
-- lib/merit/rules_badge.rb
-- lib/merit/rules_points.rb
-- lib/merit/rules_rank.rb
+- lib/merit/rules_badge_methods.rb
+- lib/merit/rules_points_methods.rb
+- lib/merit/rules_rank_methods.rb
 - merit.gemspec
 - test/dummy-mongoid/Rakefile
 - test/dummy-mongoid/app/controllers/application_controller.rb

data/lib/merit/rules_badge.rb

@@ -1,64 +0,0 @@
-module Merit
-  # La configuración para especificar cuándo aplicar cada badge va en
-  # app/models/merit/badge_rules.rb, con la siguiente sintaxis:
-  #
-  #   grant_on 'users#create', :badge => 'just', :level => 'registered' do
-  #     # Nothing, or code block which evaluates to boolean
-  #   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 BadgeRulesMethods
-    # Define rule for granting badges
-    def grant_on(action, *args, &block)
-      options = args.extract_options!
-
-      actions = action.kind_of?(String) ? [action] : action
-
-      rule = Rule.new
-      rule.badge_name = options[:badge]
-      rule.level      = options[:level]
-      rule.to         = options[:to] || :action_user
-      rule.multiple   = options[:multiple] || false
-      rule.temporary  = options[:temporary] || false
-      rule.model_name = options[:model_name] || actions[0].split('#')[0]
-      rule.block      = block
-
-      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).map &:check_rules
-    end
-
-    # Currently defined rules
-    def defined_rules
-      @defined_rules ||= {}
-    end
-  end
-end