qalam_merit 4.0.4

data/lib/merit/generators/templates/qalam_sash.erb

@@ -0,0 +1,14 @@
+### QALAM_MERIT ###
+class Merit::QalamSash < ActiveRecord::Base
+    self.table_name = "sashes"
+    has_many :badges_sashes, class_name: 'Merit::QalamBadgeSash'
+    has_many :badges, through: :badges_sashes, source: :badge
+
+    class << self
+        def user(sash_id = nil)
+            return [] unless sash_id
+
+            User.where(sash_id: sash_id)
+        end
+    end
+end

data/lib/merit/judge.rb

@@ -0,0 +1,102 @@
+require 'observer'
+
+module Merit
+  class Judge
+    include Observable
+
+    def initialize(rule, options = {})
+      @rule = rule
+      @action = options[:action]
+      Merit.observers.each do |class_name|
+        add_observer class_name.constantize.new
+      end
+    end
+
+    # Grant badge if rule applies. If it doesn't, and the badge is temporary,
+    # then remove it.
+    def apply_badges
+      if rule_applies?
+        grant_badges
+      else
+        remove_badges if @rule.temporary
+      end
+    end
+
+    def apply_points
+      return unless rule_applies?
+      sashes.each do |sash|
+        point = sash.add_points points, category: category
+        notify_observers(
+          description: I18n.t("merit.granted_points", points: points),
+          merit_object: point,
+          sash_id: point.sash_id
+        )
+      end
+    end
+
+    private
+
+    def grant_badges
+      sashes.each do |sash|
+        next unless new_or_multiple?(sash)
+        badge_sash = sash.add_badge badge.id
+        notify_observers(
+          description: I18n.t("merit.granted_badge", badge_name: badge.name),
+          merit_object: badge_sash,
+          sash_id: badge_sash.sash_id
+        )
+      end
+    end
+
+    def remove_badges
+      sashes.each do |sash|
+        sash.rm_badge badge.id
+        notify_observers(
+          description: I18n.t("merit.removed_badge", badge_name: badge.name),
+          sash_id: sash.id
+        )
+      end
+    end
+
+    def new_or_multiple?(sash)
+      !sash.badge_ids.include?(badge.id) || @rule.multiple
+    end
+
+    def rule_object
+      BaseTargetFinder.find(@rule, @action)
+    end
+
+    def rule_applies?
+      @rule.applies? rule_object
+    end
+
+    def points
+      if @rule.score.respond_to?(:call)
+        @rule.score.call(rule_object)
+      else
+        @rule.score
+      end
+    end
+
+    def category
+      @rule.category
+    end
+
+    def sashes
+      @sashes ||= SashFinder.find @rule, @action
+    end
+
+    def badge
+      @rule.badge
+    end
+
+    def notify_observers(changed_data = {})
+      changed
+      hash = {
+        granted_at: @action.created_at,
+        merit_action_id: @action.id
+      }.merge(changed_data)
+      super(hash)
+    end
+  end
+end

data/lib/merit/models/action_concern.rb

@@ -0,0 +1,50 @@
+# Merit::Action 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)
+module Merit::Models
+  module ActionConcern
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def check_unprocessed
+        where(processed: false).find_each(&:check_all_rules)
+      end
+    end
+
+    # Check rules defined for a merit_action
+    def check_all_rules
+      mark_as_processed!
+      return if had_errors
+
+      check_rules rules_matcher.select_from(Merit::AppBadgeRules), :badges
+      check_rules rules_matcher.select_from(Merit::AppPointRules), :points
+    end
+
+    private
+
+    def check_rules(rules_array, badges_or_points)
+      rules_array.each do |rule|
+        judge = Merit::Judge.new(rule, action: self)
+        judge.public_send(:"apply_#{badges_or_points}")
+      end
+    end
+
+    def mark_as_processed!
+      self.processed = true
+      save
+    end
+
+    def rules_matcher
+      @rules_matcher ||= ::Merit::RulesMatcher.new(target_model, action_method)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Merit::Models::ActiveRecord
+  class Action < ActiveRecord::Base
+    include Merit::Models::ActionConcern
+
+    self.table_name = :merit_actions
+
+    has_many :activity_logs, class_name: 'Merit::ActivityLog'
+  end
+end
+
+class Merit::Action < Merit::Models::ActiveRecord::Action; end

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

@@ -0,0 +1,11 @@
+module Merit::Models::ActiveRecord
+  class ActivityLog < ActiveRecord::Base
+    self.table_name = :merit_activity_logs
+
+    belongs_to :action, class_name: 'Merit::Action'
+    belongs_to :related_change, polymorphic: true, optional: true
+    has_one :sash, through: :related_change
+  end
+end
+
+class Merit::ActivityLog < Merit::Models::ActiveRecord::ActivityLog; end

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

@@ -0,0 +1,13 @@
+module Merit::Models::ActiveRecord
+  class BadgesSash < ActiveRecord::Base
+    include Merit::Models::BadgesSashConcern
+
+    has_many :activity_logs,
+             class_name: 'Merit::ActivityLog',
+             as: :related_change
+
+    validates_presence_of :badge_id, :sash
+  end
+end
+
+class Merit::BadgesSash < Merit::Models::ActiveRecord::BadgesSash; end

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

@@ -0,0 +1,32 @@
+module Merit::Models::ActiveRecord
+  # 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
+    include Merit::Models::SashConcern
+
+    has_many :badges_sashes, dependent: :destroy
+    has_many :scores, dependent: :destroy, class_name: 'Merit::Score'
+
+    after_create :create_scores
+
+    # Retrieve all points from a category or none if category doesn't exist
+    # By default retrieve all Points
+    # @param category [String] The category
+    # @return [ActiveRecord::Relation] containing the points
+    def score_points(options = {})
+      scope = Merit::Score::Point
+                .joins(:score)
+                .where('merit_scores.sash_id = ?', id)
+      if (category = options[:category])
+        scope = scope.where('merit_scores.category = ?', category)
+      end
+      scope
+    end
+  end
+end
+
+class Merit::Sash < Merit::Models::ActiveRecord::Sash; end

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

@@ -0,0 +1,25 @@
+module Merit::Models::ActiveRecord
+  class Score < ActiveRecord::Base
+    self.table_name = :merit_scores
+    belongs_to :sash
+    has_many :score_points,
+             dependent: :destroy,
+             class_name: 'Merit::Score::Point'
+
+    def points
+      score_points.group(:score_id).sum(:num_points).values.first || 0
+    end
+
+    class Point < ActiveRecord::Base
+      belongs_to :score, class_name: 'Merit::Score'
+      has_one :sash, through: :score
+      has_many :activity_logs,
+               class_name: 'Merit::ActivityLog',
+               as: :related_change
+      delegate :sash_id, to: :score
+    end
+  end
+end
+
+class Merit::Score < Merit::Models::ActiveRecord::Score; end
+class Merit::Score::Point < Merit::Models::ActiveRecord::Score::Point; end

data/lib/merit/models/badges_sash_concern.rb

@@ -0,0 +1,13 @@
+module Merit::Models
+  module BadgesSashConcern
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :sash
+    end
+
+    def badge
+      Merit::Badge.find(badge_id)
+    end
+  end
+end

data/lib/merit/models/base/badges_sash.rb

@@ -0,0 +1,15 @@
+module Merit
+  module Models::Base
+    module BadgesSash
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :sash
+      end
+
+      def badge
+        Merit::Badge.find(badge_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Merit
+  module Models::Base
+    module Sash
+      def badges
+        badge_ids.map { |id| Merit::Badge.find id }
+      end
+
+      def badge_ids
+        badges_sashes.map(&:badge_id)
+      end
+
+      def add_badge(badge_id)
+        bs = Merit::BadgesSash.new(badge_id: badge_id.to_i)
+        badges_sashes << bs
+        bs
+      end
+
+      def rm_badge(badge_id)
+        badges_sashes.where(badge_id: badge_id.to_i).first.try(:destroy)
+      end
+
+      # Retrieve the number of points from a category
+      # By default all points are summed up
+      # @param category [String] The category
+      # @return [Integer] The number of points
+      def points(options = {})
+        if (category = options[:category])
+          scores.where(category: category).first.try(:points) || 0
+        else
+          scores.reduce(0) { |sum, score| sum + score.points }
+        end
+      end
+
+      def add_points(num_points, options = {})
+        point = Merit::Score::Point.new
+        point.num_points = num_points
+        scores
+          .where(category: options[:category] || 'default')
+          .first_or_create
+          .score_points << point
+        point
+      end
+
+      def subtract_points(num_points, options = {})
+        add_points(-num_points, options)
+      end
+
+      private
+
+      def create_scores
+        scores << Merit::Score.create
+      end
+    end
+  end
+end

data/lib/merit/models/sash_concern.rb

@@ -0,0 +1,53 @@
+module Merit::Models
+  module SashConcern
+    def badges
+      badge_ids.map { |id| Merit::Badge.find id }
+    end
+
+    def badge_ids
+      badges_sashes.map(&:badge_id)
+    end
+
+    def add_badge(badge_id)
+      bs = Merit::BadgesSash.new(badge_id: badge_id.to_i)
+      badges_sashes << bs
+      bs
+    end
+
+    def rm_badge(badge_id)
+      badges_sashes.where(badge_id: badge_id.to_i).first.try(:destroy)
+    end
+
+    # Retrieve the number of points from a category
+    # By default all points are summed up
+    # @param category [String] The category
+    # @return [Integer] The number of points
+    def points(options = {})
+      if (category = options[:category])
+        scores.where(category: category).first.try(:points) || 0
+      else
+        scores.reduce(0) { |sum, score| sum + score.points }
+      end
+    end
+
+    def add_points(num_points, options = {})
+      point = Merit::Score::Point.new
+      point.num_points = num_points
+      scores
+        .where(category: options[:category] || 'default')
+        .first_or_create
+        .score_points << point
+      point
+    end
+
+    def subtract_points(num_points, options = {})
+      add_points(-num_points, options)
+    end
+
+    private
+
+    def create_scores
+      scores << Merit::Score.create
+    end
+  end
+end

data/lib/merit/point_rules_methods.rb

@@ -0,0 +1,33 @@
+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 PointRulesMethods
+    # Define rules on certaing actions for giving points
+    def score(points, *args, &block)
+      options = args.extract_options!
+      options_to = options.fetch(:to) { :action_user }
+
+      actions = Array.wrap(options[:on])
+
+      Array.wrap(options_to).each do |to|
+        rule = Rule.new
+        rule.score = points
+        rule.to    = to
+        rule.block = block
+        rule.category = options.fetch(:category) { :default }
+        rule.model_name = options[:model_name] if options[:model_name]
+
+        actions.each do |action|
+          defined_rules[action] ||= []
+          defined_rules[action] << rule
+        end
+      end
+    end
+
+    # Currently defined rules
+    def defined_rules
+      @defined_rules ||= {}
+    end
+  end
+end