qalam_merit 4.0.4

data/lib/merit/rank_rules_methods.rb

@@ -0,0 +1,58 @@
+module Merit
+  # 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:
+  # * :+level+ ranking level (greater is better)
+  # * :+to+ model or scope to check if new rankings apply
+  # * :+level_name+ attribute name (default is empty and results in 'level'
+  #   attribute, if set it's appended like 'level_#{level_name}')
+  module RankRulesMethods
+    # Populates +defined_rules+ hash with following hierarchy:
+    #   defined_rules[ModelToRank] = { levels => blocks }
+    def set_rank(*args, &block)
+      options = args.extract_options!
+
+      rule = Rule.new
+      rule.block = block
+      if options[:level_name].present?
+        rule.level_name = "level_#{options[:level_name]}"
+      else
+        rule.level_name = 'level'
+      end
+
+      defined_rules[options[:to]] ||= {}
+      defined_rules[options[:to]].merge!(options[:level] => rule)
+    end
+
+    # 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.sort.each do |level, rule|
+          grant_when_applies(scoped_model, rule, level)
+        end
+      end
+    end
+
+    # Currently defined rules
+    def defined_rules
+      @defined_rules ||= {}
+    end
+
+    private
+
+    def grant_when_applies(scoped_model, rule, level)
+      scoped_model.where("#{rule.level_name} < #{level}").each do |object|
+        next unless rule.applies?(object)
+
+        object.update_attribute rule.level_name, level
+      end
+    rescue ActiveRecord::StatementInvalid
+      str = "Error while granting rankings. Probably you need to add
+        #{rule.level_name} column to #{scoped_model.class.name}."
+      raise RankAttributeNotDefined, str
+    end
+  end
+end

data/lib/merit/reputation_change_observer.rb

@@ -0,0 +1,19 @@
+module Merit
+  class ReputationChangeObserver
+    def update(changed_data)
+      ActivityLog.create(
+        description:    changed_data[:description],
+        related_change: related_change(changed_data),
+        action_id:      changed_data[:merit_action_id]
+      )
+    end
+
+    private
+
+    def related_change(data)
+      if data[:merit_object].respond_to?(:activity_logs)
+        data[:merit_object]
+      end
+    end
+  end
+end

data/lib/merit/rule.rb

@@ -0,0 +1,35 @@
+module Merit
+  # Rules has a badge name and level, a target to badge, a conditions block
+  # and a temporary option.
+  # Could split this class between badges and rankings functionality
+  class Rule
+    attr_accessor :badge_id, :badge_name, :level, :to, :model_name, :level_name,
+                  :multiple, :temporary, :score, :block, :category
+
+    # Does this rule's condition block apply?
+    def applies?(target_obj = nil)
+      return true if block.nil? # no block given: always true
+
+      case block.arity
+      when 1 # Expects target object
+        if target_obj.present?
+          block.call(target_obj)
+        else
+          Rails.logger.warn '[merit] no target_obj found on Rule#applies?'
+          false
+        end
+      when 0
+        block.call
+      end
+    end
+
+    # Get rule's related Badge.
+    def badge
+      if badge_id
+        Merit::Badge.find(badge_id)
+      else
+        Merit::Badge.find_by_name_and_level(badge_name, level)
+      end
+    end
+  end
+end

data/lib/merit/rules_matcher.rb

@@ -0,0 +1,24 @@
+module Merit
+  class RulesMatcher
+    def initialize(path, action_name)
+      @path = path
+      @action_name = action_name
+    end
+
+    def select_from(rules)
+      rules.select do |glob, _|
+        entire_path =~ /^#{Regexp.new(glob)}$/
+      end.values.flatten
+    end
+
+    def any_matching?
+      select_from(AppBadgeRules).any? || select_from(AppPointRules).any?
+    end
+
+    private
+
+    def entire_path
+      @entire_path ||= [@path, @action_name].join('#')
+    end
+  end
+end

data/lib/merit/sash_finder.rb

@@ -0,0 +1,15 @@
+module Merit
+  class SashFinder
+    def self.find(rule, action)
+      targets(rule, action).map(&:_sash)
+    rescue NoMethodError
+      Rails.logger.warn "[merit] Couldn't find model to grant reputation to. " \
+                        "Refer to https://github.com/tute/merit/issues/171#issuecomment-44185696."
+      []
+    end
+
+    def self.targets(rule, action)
+      TargetFinder.find(rule, action).compact
+    end
+  end
+end

data/lib/merit/target_finder.rb

@@ -0,0 +1,43 @@
+module Merit
+  class TargetFinder < Struct.new(:rule, :action)
+    def self.find(*args)
+      new(*args).find
+    end
+
+    def find
+      target = case rule.to
+               when :itself then
+                 base_target
+               when :action_user then
+                 action_user
+               else
+                 other_target
+               end
+      Array.wrap(target)
+    end
+
+    private
+
+    def base_target
+      BaseTargetFinder.find rule, action
+    end
+
+    def action_user
+      user = Merit.user_model.find_by_id action.user_id
+      if user.nil?
+        user_model = Merit.user_model
+        str = "[merit] no #{user_model} found with id #{action.user_id}"
+        Rails.logger.warn str
+      end
+      user
+    end
+
+    def other_target
+      base_target.send rule.to
+    rescue NoMethodError
+      str = "[merit] NoMethodError on `#{base_target.class.name}##{rule.to}`" \
+            ' (called from Merit::TargetFinder#other_target)'
+      Rails.logger.warn str
+    end
+  end
+end

data/qalam_merit.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name        = "qalam_merit"
+  s.summary     = "Reputation engine for Rails apps"
+  s.description = "Manage badges, points and rankings (reputation) in your Rails app."
+  s.homepage    = "https://github.com/merit-gem/merit"
+  s.files       = `git ls-files`.split("\n").reject{|f| f =~ /^\./ }
+  s.test_files  = `git ls-files -- test/*`.split("\n")
+  s.license     = 'MIT'
+  s.version     = '4.0.4'
+  s.authors     = ["Tute Costa", "Ahmed Abdelhamid"]
+  s.email       = ['tutecosta@gmail.com', 'a.hamid@nezam.io']
+
+  s.required_ruby_version = '>= 2.3.0'
+
+  s.add_runtime_dependency 'zeitwerk'
+
+  s.add_development_dependency 'rails', '>= 5.1.6'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'minitest-rails'
+  s.add_development_dependency 'mocha'
+end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+Dummy::Application.load_tasks

data/test/dummy/app/controllers/admin/users_controller.rb

@@ -0,0 +1,9 @@
+class Admin::UsersController < ApplicationController
+  def index
+    @users = User.all
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @users }
+    end
+  end
+end

data/test/dummy/app/controllers/api/comments_controller.rb

@@ -0,0 +1,5 @@
+class Api::CommentsController < ApplicationController
+  def show
+    render json: {}
+  end
+end

data/test/dummy/app/controllers/api/users_controller.rb

@@ -0,0 +1,5 @@
+class Api::UsersController < ApplicationController
+  def index
+    render json: User.all.to_json
+  end
+end

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,7 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+
+  def current_user
+    @current_user ||= User.first
+  end
+end

data/test/dummy/app/controllers/comments_controller.rb

@@ -0,0 +1,56 @@
+class CommentsController < ApplicationController
+  def index
+    @comments = Comment.all
+  end
+
+  def show
+    @comment = Comment.find(params[:id])
+  end
+
+  def new
+    @comment = Comment.new
+  end
+
+  def edit
+    @comment = Comment.find(params[:id])
+  end
+
+  def vote
+    @comment = Comment.find(params[:id])
+    @comment.votes += params[:value].to_i
+    @comment.save
+    redirect_to(comments_url, :notice => 'Vote added!')
+  end
+
+  def create
+    @comment = Comment.new(comment_params)
+    if @comment.save
+      redirect_to(@comment, :notice => 'Comment was successfully created.')
+    else
+      render "new"
+    end
+  end
+
+  def update
+    @comment = Comment.find(params[:id])
+    if @comment.update(comment_params)
+      redirect_to(@comment, :notice => 'Comment was successfully updated.')
+    else
+      render "edit"
+    end
+  end
+
+  # DELETE /comments/1
+  # DELETE /comments/1.xml
+  def destroy
+    @comment = Comment.find(params[:id])
+    @comment.destroy
+    redirect_to(comments_url)
+  end
+
+  private
+
+  def comment_params
+    params.require(:comment).permit!
+  end
+end

data/test/dummy/app/controllers/registrations_controller.rb

@@ -0,0 +1,21 @@
+class RegistrationsController < ApplicationController
+  def update
+    @user = User.find(params[:id])
+
+    respond_to do |format|
+      if @user.update(user_params)
+        format.html { redirect_to(@user, :notice => 'User was successfully updated.') }
+        format.xml  { head :ok }
+      else
+        format.html { render "edit" }
+        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  private
+
+    def user_params
+      params.require(:user).permit!
+    end
+end

data/test/dummy/app/controllers/users_controller.rb

@@ -0,0 +1,38 @@
+class UsersController < ApplicationController
+  def index
+    @users = User.all
+  end
+
+  def show
+    @user = User.find(params[:id])
+  end
+
+  def new
+    @user = User.new
+  end
+
+  def edit
+    @user = User.find(params[:id])
+  end
+
+  def create
+    @user = User.new(user_params)
+    if @user.save
+      redirect_to(@user, :notice => 'User was successfully created.')
+    else
+      render "new"
+    end
+  end
+
+  def destroy
+    @user = User.find(params[:id])
+    @user.destroy
+    redirect_to(users_url)
+  end
+
+  private
+
+  def user_params
+    params.require(:user).permit!
+  end
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/models/address.rb

@@ -0,0 +1,3 @@
+class Address < ActiveRecord::Base
+  belongs_to :user
+end

data/test/dummy/app/models/comment.rb

@@ -0,0 +1,13 @@
+class Comment < ActiveRecord::Base
+  def friend
+    User.find_by_name('friend')
+  end
+
+  has_merit
+
+  belongs_to :user
+
+  validates :name, :comment, :user_id, :presence => true
+
+  delegate :comments, :to => :user, :prefix => true
+end

data/test/dummy/app/models/dummy_observer.rb

@@ -0,0 +1,3 @@
+class DummyObserver
+  def update(*); end
+end

data/test/dummy/app/models/merit/badge_rules.rb

@@ -0,0 +1,66 @@
+# +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).
+
+module Merit
+  class BadgeRules
+    include Merit::BadgeRulesMethods
+
+    def initialize
+      # If it creates user, grant badge
+      # Should be "current_user" after registration for badge to be granted.
+      # Example rule with block with no parameters
+      grant_on 'users#create', badge: 'just-registered', to: :itself do
+        true
+      end
+
+      # For regression test: if condition doesn't hold, it doesn't check
+      # sashes to badge. Useful for polymorphic relations where not every
+      # model has reputation. See https://github.com/tute/merit/issues/134.
+      grant_on 'users#create', badge: 'just-registered', to: :model_with_no_reputation do |user|
+        user.model_with_no_reputation.respond_to?(:_sash)
+      end
+
+      # Example rule for multiple badge granting
+      grant_on 'users#index', badge: 'gossip', multiple: true
+
+      # Example rule for badge granting in namespaced controllers
+      grant_on 'admin/users#index', badge: 'visited_admin'
+
+      # Example rule for testing badge granting in differently namespaced controllers.
+      grant_on '.*users#index', badge: 'wildcard_badge', multiple: true
+
+      # If it has 10 comments, grant commenter-10 badge, find badge by badge_id
+      grant_on 'comments#create', badge_id: 1, level: 10 do |comment|
+        comment.user.comments.count >= 10
+      end
+      # Testing badge granting in more than one rule per action with different targets
+      grant_on 'comments#create', badge: 'has_commenter_friend', to: :friend do |comment|
+        comment.user.comments.count >= 10
+      end
+
+      # If it has at least 10 votes, grant relevant-commenter badge
+      grant_on 'comments#vote', badge: 'relevant-commenter', to: :user do |comment|
+        comment.votes >= 10
+      end
+
+      # Changes his name by one wider than 4 chars (arbitrary ruby code and custom model_name)
+      # This badge is temporary (user may lose it)
+      grant_on 'registrations#update', badge: 'autobiographer', temporary: true, model_name: 'User' do |user|
+        user.name.length > 4
+      end
+    end
+  end
+end