redmine_avm 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 491c7e0c46f51ace5676cfbb1025bb731ab26ad3ec4814763cf66a6ec06d9c3b
+  data.tar.gz: b051350b016dcf1055111222f7b2c83807ecf9a4c35ddc553623333665f0b73d
+SHA512:
+  metadata.gz: acf3a7957aad165d003a34c0333b62fb3c71c4a6d59cbbd4ea6e7bcc8693223adc3d9869f17a67a6c9e1d70d8decb77c9c92545795dbe04369ef54572598405a
+  data.tar.gz: cbbf26130460b0dccbe194cee629177eab52f696089e0b3ae3445f3eef2ed203a50989de2114665a59837e79fb08b051f937fb6141586da3d3bea6defe2a63b1

data/app/controllers/issue_status_assigns_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class IssueStatusAssignsController < ApplicationController
+  before_action :require_admin, :active_scaffold_set_dynamic_options
+  layout 'admin'
+
+  active_scaffold :issue_status_assign do |conf|
+    conf.columns[:issue_status].form_ui = :select
+    conf.columns[:issue_field].form_ui = :select
+  end
+
+  private
+
+  def active_scaffold_set_dynamic_options
+    active_scaffold_config.columns[:issue_field].options =
+      { options: issue_field_options }
+  end
+
+  def issue_field_options
+    CustomField.where(type: 'IssueCustomField', field_format: 'user')
+               .map { |cf| [cf.id, cf.to_s] }
+  end
+end

data/app/helpers/issue_status_assigns_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module IssueStatusAssignsHelper
+  def options_for_association_conditions(association, record)
+    if association.name == :issue_field
+      { type: 'IssueCustomField', field_format: 'user' }
+    else
+      super
+    end
+  end
+end

data/app/models/issue_status_assign.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class IssueStatusAssign < ActiveRecord::Base
+  belongs_to :issue_status, dependent: :destroy
+  belongs_to :issue_field, class_name: 'CustomField', dependent: :destroy
+
+  validates :issue_status, presence: true, uniqueness: true
+  validates :issue_field, presence: true
+end

data/app/views/settings/_avm.html.erb

@@ -0,0 +1,49 @@
+<p>
+  <label>Usuário administrador</label>
+  <select name="settings[admin_user_id]">
+    <%= options_for_select(User.all.order('firstname','lastname').collect {|u| [ u.to_s, u.id ] }, settings['admin_user_id'] ) %>
+  </select>
+</p>
+<p>
+  <label>Situação de tarefa indefinda.</label>
+  <select name="settings[issue_status_undefined_id]">
+    <%= options_for_select([['-','']] + IssueStatus.all.collect {|p| [ p.name, p.id ] }, settings['issue_status_undefined_id'] ) %>
+  </select>
+</p>
+<p>
+  <label>Situação de tarefa bloqueada.</label>
+  <select name="settings[issue_status_blocked_id]">
+    <%= options_for_select([['-','']] + IssueStatus.all.collect {|p| [ p.name, p.id ] }, settings['issue_status_blocked_id'] ) %>
+  </select>
+</p>
+<p>
+  <label>Situação de tarefa desbloqueada.</label>
+  <select name="settings[issue_status_unblocked_id]">
+    <%= options_for_select([['-','']] + IssueStatus.all.collect {|p| [ p.name, p.id ] }, settings['issue_status_unblocked_id'] ) %>
+  </select>
+</p>
+<p>
+  <label>Título da seção de dependências.</label>
+  <%= text_field_tag 'settings[dependencies_section_title]',
+    settings['dependencies_section_title'] %>
+</p>
+<p>
+  <label>Mensagem para seção de dependências não encontrada.</label>
+  <%= text_area_tag 'settings[no_dependencies_section_message]',
+    settings['no_dependencies_section_message'] %>
+</p>
+<p>
+  <label>Mensagem para dependências ausentes na seção de dependências.</label>
+  <%= text_area_tag 'settings[dependencies_section_missing_dependencies_message]',
+    settings['dependencies_section_missing_dependencies_message'] %>
+</p>
+<p>
+  <label>Título da seção de motivação.</label>
+  <%= text_field_tag 'settings[motivation_section_title]',
+    settings['motivation_section_title'] %>
+</p>
+<p>
+  <label>Mensagem indefinição por imotivação.</label>
+  <%= text_area_tag 'settings[unmotivated_message]',
+    settings['unmotivated_message'] %>
+</p>

data/config/initializers/000_dependencies.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+Redmine::Plugin.post_register :redmine_avm do
+  # Source: https://github.com/esquilo-azul/redmine_events_manager
+  requires_redmine_plugin(:redmine_events_manager, version_or_higher: '0.4.2')
+end

data/config/initializers/events_manager.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+EventsManager.add_listener(Issue, :create, 'Avm::Listeners::IssueAutoUndefine')
+EventsManager.add_listener(Issue, :update, 'Avm::Listeners::IssueAutoUndefine')
+EventsManager.add_listener(IssueRelation, :create, 'Avm::Listeners::IssueAutoUndefine')
+EventsManager.add_listener(IssueRelation, :delete, 'Avm::Listeners::IssueAutoUnblock')
+EventsManager.add_listener(Issue, :delete, 'Avm::Listeners::IssueAutoUnblock')
+EventsManager.add_listener(Issue, :update, 'Avm::Listeners::IssueAutoUnblock')
+EventsManager.add_listener(Issue, :create, 'Avm::Listeners::IssueAutoAssign')
+EventsManager.add_listener(Issue, :update, 'Avm::Listeners::IssueAutoAssign')
+EventsManager.add_listener(Issue, :update,
+                           'Avm::Listeners::IssueDependenciesSectionCheck')
+EventsManager.add_listener(IssueRelation, :create,
+                           'Avm::Listeners::IssueDependenciesSectionCheck')
+[[Issue, :create], [Issue, :update], [IssueRelation, :create]].each do |v|
+  EventsManager.add_listener(v.first, v.last, 'Avm::Listeners::IssueMotivationCheck')
+end

data/config/initializers/redmine_plugins_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+default_value = {
+  dependencies_section_title: 'Dependencies',
+  no_dependencies_section_message: <<MESSAGE.strip_heredoc,
+                                                   Dependencies section not found.
+                                                   Customize this message in plugin AVM's configuration.
+MESSAGE
+  dependencies_section_missing_dependencies_message: <<MESSAGE.strip_heredoc,
+                                                   Missing dependencies found dependencies section: %{ids}.
+                                                   Customize this message in plugin AVM's configuration.
+MESSAGE
+  motivation_section_title: 'Motivation',
+  unmotivated_message: 'This issue is not motivated.'
+}
+
+if ActiveRecord::Base.connection.table_exists? ::User.table_name
+  default_admin = ::User.where(id: 1, admin: true).first
+  default_value[:admin_user_id] = default_admin.id if default_admin
+end
+
+::RedminePluginsHelper::Settings.default(:redmine_avm, default_value)

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  issue_assign_message: |
+    Assigned to *%{user}* because:
+
+    # The issue's status is *%{issue_status}*;
+    # For this status the expected role is *%{issue_field}*;
+    # *%{user}* is the issue's *%{issue_field}*.
+  issue_unblock_message: 'This issue was unblocked because has no open dependencies.'
+  issue_undefine_message: 'This issue was undefined because it has undefined dependencies: %{undefined_dependencies_ids}.'
+  label_issue_status_assigns: Issue status assigns

data/config/locales/pt-BR.yml

@@ -0,0 +1,10 @@
+pt-BR:
+  issue_assign_message: |
+    Atribuído para *%{user}* porque:
+
+    # A tarefa está na situação *%{issue_status}*;
+    # Nessa situação o responsável esperado é o *%{issue_field}*;
+    # *%{user}* é o *%{issue_field}* da tarefa.
+  issue_unblock_message: 'Esta tarefa foi desbloqueada porque não possui dependências abertas.'
+  issue_undefine_message: 'Esta tarefa foi indefinida porque possui dependências indefinidas: %{undefined_dependencies_ids}.'
+  label_issue_status_assigns: Atribuição por situações de tarefa

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+RedmineApp::Application.routes.draw do
+  resources(:issue_status_assigns) { as_routes }
+end

data/db/migrate/20160516164053_create_issue_status_assigns.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class CreateIssueStatusAssigns < ActiveRecord::Migration
+  def change
+    create_table :issue_status_assigns do |t|
+      t.references :issue_status
+      t.references :issue_field
+    end
+  end
+end

data/db/migrate/20180711164719_rename_plugin_avm_to_redmine_avm.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class RenamePluginAvmToRedmineAvm < ActiveRecord::Migration
+  class Settings < ActiveRecord::Base
+  end
+
+  def up
+    rename_plugin('avm', 'redmine_avm')
+  end
+
+  def down
+    rename_plugin('redmine_avm', 'avm')
+  end
+
+  private
+
+  def rename_plugin(from, to)
+    old_record = Setting.find_by(name: from)
+    return if old_record.blank?
+
+    new_record = Setting.find_by(name: to)
+    if new_record.present?
+      new_value = plugin_setting_value(old_record).value.merge(plugin_setting_value(new_record))
+      new_record.update!(value: new_value)
+      old_record.destroy!
+    else
+      old_record.update!(name: to)
+    end
+  end
+
+  def plugin_setting_value(record)
+    if record.value.blank?
+      {}.with_indifferent_access
+    elsif record.value.is_a?(Hash)
+      record.value
+    else
+      raise "#{record} value is not Hash or blank"
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'redmine'
+
+require 'avm/patches/issue_patch'
+require 'avm/patches/test_case_patch'
+
+Redmine::Plugin.register :redmine_avm do
+  name 'Redmine\'s AVM plugin'
+  author ::RedmineNonprojectModules::AUTHOR
+  description ::RedmineAvm::SUMMARY
+  version ::RedmineNonprojectModules::VERSION
+  url ::RedmineNonprojectModules::HOMEPAGE
+
+  settings(partial: 'settings/avm')
+
+  Redmine::MenuManager.map :admin_menu do |menu|
+    menu.push :issue_status_assigns, { controller: 'issue_status_assigns', action: 'index' },
+              caption: :label_issue_status_assigns
+  end
+end

data/lib/avm/issue/assign.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Avm
+  module Issue
+    class Assign
+      attr_reader :issue
+
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def run
+        return unless issue_status_assign && issue_has_assign_field?
+        return unless issue.assigned_to || issue_status_user
+        return if issue.assigned_to == issue_status_user
+
+        assign
+      end
+
+      private
+
+      def issue_status_assign
+        @issue_status_assign ||= IssueStatusAssign.where(issue_status: issue.status).first
+      end
+
+      def issue_has_assign_field?
+        issue.available_custom_fields.include?(issue_status_assign.issue_field)
+      end
+
+      def issue_status_user
+        id = issue.custom_field_value(issue_status_assign.issue_field)
+        id.present? ? User.find(id) : nil
+      end
+
+      def assign
+        user = issue_status_user
+        Rails.logger.debug("Assigning #{user} to #{issue}")
+        user_label = user ? user.to_s : 'NENHUM'
+        @issue.init_journal(
+          Avm::Settings.admin_user,
+          I18n.translate(:issue_assign_message, user: user_label, issue_status: issue.status,
+                                                issue_field: issue_status_assign.issue_field.name)
+        )
+        @issue.assigned_to = user
+        @issue.save!
+      end
+    end
+  end
+end

data/lib/avm/issue/dependencies_section_check.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Avm
+  module Issue
+    class DependenciesSectionCheck
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def run
+        return if @issue.closed?
+        return if @issue.dependencies.empty?
+
+        unless @issue.dependencies_section
+          Rails.logger.info("\##{@issue.id}: no section found")
+          undefine_no_dependencies_secion
+          return
+        end
+        return if all_dependencies_in_dependencies_section?
+
+        Rails.logger.info("\##{@issue.id}: missing dependencies in dependency section")
+        undefine_no_all_dependencies
+      end
+
+      private
+
+      def all_dependencies_in_dependencies_section?
+        sec_deps = @issue.dependencies_section_dependencies
+        @issue.dependencies.all? { |d| sec_deps.include?(d.id) }
+      end
+
+      def undefine_no_dependencies_secion
+        @issue.init_journal(
+          Avm::Settings.admin_user,
+          Avm::Settings.no_dependencies_section_message
+        )
+        @issue.status = Avm::Settings.issue_status_undefined
+        @issue.save!
+      end
+
+      def undefine_no_all_dependencies
+        @issue.init_journal(
+          Avm::Settings.admin_user,
+          format(Avm::Settings.dependencies_section_missing_dependencies_message,
+                 ids: no_dependencies_section_ids_string)
+        )
+        @issue.status = Avm::Settings.issue_status_undefined
+        @issue.save!
+      end
+
+      def no_dependencies_section_ids_string
+        sec_deps = @issue.dependencies_section_dependencies
+        deps = @issue.dependencies.map(&:id)
+        (deps - sec_deps).map { |id| "##{id}" }.join(', ')
+      end
+    end
+  end
+end

data/lib/avm/issue/motivation_check.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Avm
+  module Issue
+    class MotivationCheck
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def run
+        return if motivated?
+
+        Rails.logger.info("\##{@issue.id}: unmotivated")
+        undefine
+      end
+
+      private
+
+      def motivated?
+        @issue.closed? || @issue.motivated?
+      end
+
+      def undefine
+        @issue.init_journal(
+          Avm::Settings.admin_user,
+          Avm::Settings.unmotivated_message
+        )
+        @issue.status = Avm::Settings.issue_status_undefined
+        @issue.save!
+      end
+    end
+  end
+end

data/lib/avm/issue/unblock.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Avm
+  module Issue
+    class Unblock
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def run
+        msg = unblock?
+        if msg
+          Rails.logger.debug(msg)
+        else
+          Rails.logger.debug("##{@issue.id} has no open dependencies. Unblocking...")
+          unblock
+        end
+      end
+
+      private
+
+      def unblock?
+        return "##{@issue.id} is not blocked" unless status_blocked?
+        return "##{@issue.id} has open dependencies" if open_dependencies?
+      end
+
+      def status_blocked?
+        @issue.status == Avm::Settings.issue_status_blocked
+      end
+
+      def open_dependencies?
+        @issue.dependencies.any? { |d| !d.closed? }
+      end
+
+      def unblock
+        @issue.init_journal(
+          Avm::Settings.admin_user,
+          I18n.translate(:issue_unblock_message)
+        )
+        @issue.status = Avm::Settings.issue_status_unblocked
+        @issue.save!
+      end
+    end
+  end
+end

data/lib/avm/issue/undefine.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Avm
+  module Issue
+    class Undefine
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def run
+        msg = undefine?
+        if msg
+          Rails.logger.debug(msg)
+        else
+          Rails.logger.debug("##{@issue.id} has undefined dependencies. Undefining...")
+          undefine
+        end
+      end
+
+      private
+
+      def undefine?
+        return "##{@issue.id} already undefined" if @issue.undefined?
+        return "##{@issue.id} already closed" if @issue.closed?
+        return "##{@issue.id} has no undefined dependencies" unless @issue.dependencies.any?(
+          &:undefined?
+        )
+      end
+
+      def undefine
+        @issue.init_journal(
+          Avm::Settings.admin_user,
+          I18n.translate(
+            :issue_undefine_message,
+            undefined_dependencies_ids: undefined_dependency_ids_string
+          )
+        )
+        @issue.status = Avm::Settings.issue_status_undefined
+        @issue.save!
+      end
+
+      def undefined_dependency_ids_string
+        @issue.dependencies.select(&:undefined?).map { |i| "##{i.id}" }.join(', ')
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_assign.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoAssign
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def run
+        issue = issue_to_check
+        Avm::Issue::Assign.new(issue).run if issue
+      end
+
+      private
+
+      def issue_to_check
+        return event.data if event.issue_create?
+        return event.data.issue if event.issue_update?
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_unblock.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUnblock
+      include IssueDelete
+      include IssueRelationDelete
+      include IssueUpdate
+
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def run
+        return if check_conditions
+
+        Rails.logger.debug("Unblock condition not found for #{@event}")
+      end
+
+      def check_conditions
+        %w[issue_relation_deleted issue_deleted issue_updated].any? do |m|
+          issues = send(m)
+          next unless issues
+
+          issues.each do |issue|
+            Rails.logger.debug("#{m}: #{issue}")
+            Avm::Issue::Unblock.new(issue).run
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_unblock/issue_delete.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUnblock
+      module IssueDelete
+        def issue_deleted
+          return unless event.entity == ::Issue && event.action == :delete
+
+          ::Issue.where(status: Avm::Settings.issue_status_blocked)
+        end
+
+        private
+
+        def issue
+          event.data
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_unblock/issue_relation_delete.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUnblock
+      module IssueRelationDelete
+        def issue_relation_deleted
+          return unless event.entity == IssueRelation && event.action == :delete
+          return unless relation.relation_type == IssueRelation::TYPE_BLOCKS
+
+          [relation.issue_to]
+        end
+
+        private
+
+        def relation
+          event.data
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_unblock/issue_update.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUnblock
+      module IssueUpdate
+        def issue_updated
+          return unless issue_update_event?
+          return [issue] if status_changed_to_blocked?
+          return issue.r_dependencies if status_changed_to_closed?
+        end
+
+        private
+
+        def issue_update_event?
+          event.entity == ::Issue && event.action == :update
+        end
+
+        def journal
+          event.data
+        end
+
+        def issue
+          journal.issue
+        end
+
+        def status_changed_to_blocked?
+          new_integer_value('status_id') == Avm::Settings.issue_status_blocked.id
+        end
+
+        def new_integer_value(attr)
+          d = journal.detail_for_attribute(attr)
+          return nil unless d
+
+          d.value.to_i
+        end
+
+        def status_changed_to_closed?
+          sid = new_integer_value('status_id')
+          sid ? IssueStatus.find(sid).is_closed : false
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_undefine.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUndefine
+      include IssueCreate
+      include IssueUpdate
+      include IssueRelationCreate
+
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def run
+        return if check_conditions
+
+        Rails.logger.debug("Undefine condition not found for #{@event}")
+      end
+
+      def check_conditions
+        %w[issue_created_undefined issue_updated_undefined
+           issue_relation_created_undefined].any? do |m|
+          issues = send(m)
+          next unless issues
+
+          issues.each do |issue|
+            Rails.logger.debug("#{m}: #{issue}")
+            Avm::Issue::Undefine.new(issue).run
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_undefine/issue_create.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUndefine
+      module IssueCreate
+        def issue_created_undefined
+          return unless event.entity == Issue && event.action == :create
+          return unless issue.status == Avm::Settings.issue_status_undefined
+          return unless issue.parent
+
+          [issue.parent]
+        end
+
+        private
+
+        def issue
+          event.data
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_undefine/issue_relation_create.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUndefine
+      module IssueRelationCreate
+        def issue_relation_created_undefined
+          return unless @event.entity == IssueRelation && @event.action == :create
+          return unless relation.relation_type == IssueRelation::TYPE_BLOCKS
+          return unless relation.issue_from.status == Avm::Settings.issue_status_undefined
+
+          [relation.issue_to]
+        end
+
+        private
+
+        def relation
+          event.data
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_auto_undefine/issue_update.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueAutoUndefine
+      module IssueUpdate
+        def issue_updated_undefined
+          return unless issue_update_event?
+          return journal.issue.r_dependencies if status_changed_to_undefined?
+          return [journal.issue] if status_changed_from_undefined?
+          return [journal.issue.parent] if parent_changed_and_undefined?
+        end
+
+        private
+
+        def issue_update_event?
+          @event.entity == Issue && @event.action == :update
+        end
+
+        def journal
+          @event.data
+        end
+
+        def status_changed_to_undefined?
+          new_integer_value('status_id') == Avm::Settings.issue_status_undefined.id
+        end
+
+        def status_changed_from_undefined?
+          old_integer_value('status_id') == Avm::Settings.issue_status_undefined.id
+        end
+
+        def parent_changed_and_undefined?
+          new_integer_value('parent_id') && journal.issue.undefined?
+        end
+
+        def new_integer_value(attr)
+          d = journal.detail_for_attribute(attr)
+          return nil unless d
+
+          d.value.to_i
+        end
+
+        def old_integer_value(attr)
+          d = journal.detail_for_attribute(attr)
+          return nil unless d
+
+          d.old_value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_dependencies_section_check.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueDependenciesSectionCheck
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def run
+        issue = issue_to_check
+        return unless issue
+        return if issue.status == Avm::Settings.issue_status_undefined
+
+        Avm::Issue::DependenciesSectionCheck.new(issue).run if issue
+      end
+
+      private
+
+      def issue_to_check
+        return event.data.issue if event.issue_update?
+        return event.data.issue_to if event.issue_relation_create? &&
+                                      event.data.relation_type == IssueRelation::TYPE_BLOCKS
+      end
+    end
+  end
+end

data/lib/avm/listeners/issue_motivation_check.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module Listeners
+    class IssueMotivationCheck
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def run
+        issue = issue_to_check
+        return unless issue
+        return if issue.status == Avm::Settings.issue_status_undefined
+
+        Avm::Issue::MotivationCheck.new(issue).run if issue
+      end
+
+      private
+
+      def issue_to_check
+        return event.data.issue if event.issue_update?
+        return event.data.issue_to if event.issue_relation_create? &&
+                                      event.data.relation_type == IssueRelation::TYPE_BLOCKS
+      end
+    end
+  end
+end

data/lib/avm/patches/issue_patch.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Avm
+  module Patches
+    module IssuePatch
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:include, MotivationMethods)
+      end
+
+      module InstanceMethods
+        def undefined?
+          status == ::Avm::Settings.issue_status_undefined
+        end
+
+        def description_section(section_title)
+          ['h\1\.', '----', '$'].each do |e|
+            m = /h([0-9])\.\s*#{Regexp.escape(section_title)}(.+)#{e}/m
+                .match(description)
+            return m[2].strip + "\r\n" if m
+          end
+          nil
+        end
+
+        def dependencies
+          children.all + relations_to.select do |r|
+            r.relation_type == ::IssueRelation::TYPE_BLOCKS
+          end.map(&:issue_from)
+        end
+
+        def r_dependencies
+          rd = []
+          rd << parent if parent
+          rd + relations_from.select do |r|
+            r.relation_type == ::IssueRelation::TYPE_BLOCKS
+          end.map(&:issue_to)
+        end
+
+        def dependencies_section
+          description_section(::Avm::Settings.dependencies_section_title)
+        end
+
+        def dependencies_section_dependencies
+          s = dependencies_section
+          return [] unless s
+
+          s.scan(/\#([0-9]+)/).map { |x| x[0].to_i }
+        end
+      end
+
+      module MotivationMethods
+        def motivated?
+          motivated_by_self? || motivated_by_relations?
+        end
+
+        def motivated_by_self?
+          !undefined? && motivation_section.present?
+        end
+
+        def motivated_by_relations?
+          !undefined? && r_dependencies.any?(&:motivated?)
+        end
+
+        def motivation_section
+          description_section(::Avm::Settings.motivation_section_title)
+        end
+      end
+    end
+  end
+end
+
+unless ::Issue.included_modules.include? ::Avm::Patches::IssuePatch
+  ::Issue.send(:include, ::Avm::Patches::IssuePatch)
+end

data/lib/avm/patches/test_case_patch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Avm
+  module Patches
+    module TestCasePatch
+      def self.included(base)
+        base.setup do
+          s = ::Setting.plugin_redmine_avm.dup || {}
+          s['issue_status_undefined_id'] = 1
+          s['issue_status_blocked_id'] = 4
+          s['issue_status_unblocked_id'] = 2
+          s['admin_user_id'] = 1
+          ::Setting.plugin_redmine_avm = s
+          ::ListenerOption.listener_enable('Avm::Listeners::IssueMotivationCheck', false)
+        end
+      end
+    end
+  end
+end
+
+if Rails.env.test?
+  require Rails.root.join('test', 'test_helper.rb')
+  unless ::ActiveSupport::TestCase.included_modules.include? Avm::Patches::TestCasePatch
+    ::ActiveSupport::TestCase.send(:include, Avm::Patches::TestCasePatch)
+  end
+end

data/lib/avm/settings.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Avm
+  class Settings
+    class << self
+      def issue_status_undefined(raise_if_empty = true)
+        issue_status('issue_status_undefined_id', 'indefida', raise_if_empty)
+      end
+
+      def issue_status_blocked(raise_if_empty = true)
+        issue_status('issue_status_blocked_id', 'bloqueada', raise_if_empty)
+      end
+
+      def issue_status_unblocked(raise_if_empty = true)
+        issue_status('issue_status_unblocked_id', 'desbloqueada', raise_if_empty)
+      end
+
+      def admin_user(raise_if_empty = true)
+        if Setting.plugin_redmine_avm['admin_user_id'].present?
+          User.find(Setting.plugin_redmine_avm['admin_user_id'])
+        elsif raise_if_empty
+          raise 'Usuário administrador não configurado. Acesse /settings/plugin/avm.'
+        end
+      end
+
+      def dependencies_section_title
+        required_text(__method__)
+      end
+
+      def no_dependencies_section_message
+        required_text(__method__)
+      end
+
+      def dependencies_section_missing_dependencies_message
+        required_text(__method__)
+      end
+
+      def motivation_section_title
+        required_text(__method__)
+      end
+
+      def unmotivated_message
+        required_text(__method__)
+      end
+
+      private
+
+      def issue_status(key, message, raise_if_empty)
+        if Setting.plugin_redmine_avm[key].present?
+          IssueStatus.find(Setting.plugin_redmine_avm[key])
+        elsif raise_if_empty
+          raise "Situação de tarefa #{message} não configurada. Acesse /settings/plugin/avm."
+        end
+      end
+
+      def required_text(key)
+        v = Setting.plugin_redmine_avm[key]
+        return v if v.present?
+
+        raise "Setting.plugin_redmine_avm[#{key}] is empty"
+      end
+    end
+  end
+end

data/lib/redmine_avm.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RedmineAvm
+  require 'redmine_avm/version'
+end

data/lib/redmine_avm/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RedmineAvm
+  AUTHOR = 'Eduardo Henrique Bogoni'
+  HOMEPAGE = 'https://github.com/esquilo-azul/redmine_avm'
+  SUMMARY = 'AVM support for Redmine.'
+  VERSION = '0.3.3'
+end

data/lib/tasks/issue.rake

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+namespace :avm do
+  namespace :issue do
+    desc 'Verifica auto-indefinição de uma tarefa'
+    task :undefine, [:issue_id] => :environment do |_t, args|
+      Avm::Issue::Undefine.new(Issue.find(args.issue_id)).run
+    end
+
+    desc 'Verifica auto-indefinição de todas as tarefas indefinidas'
+    task undefine_all: :environment do |_t, _args|
+      Issue.where.not(status: Avm::Settings.issue_status_undefined).each do |i|
+        Avm::Issue::Undefine.new(i).run
+      end
+    end
+
+    desc 'Verifica auto-desbloqueio de uma tarefa'
+    task unblock: :environment do |_t, _args|
+      Issue.where(status: Avm::Settings.issue_status_blocked).each do |i|
+        Avm::Issue::Unblock.new(i).run
+      end
+    end
+
+    desc 'Verifica auto-desbloqueio de todas as tarefas'
+    task unblock_all: :environment do |_t, _args|
+      Issue.where(status: Avm::Settings.issue_status_blocked).each do |i|
+        Avm::Issue::Unblock.new(i).run
+      end
+    end
+
+    desc 'Verifica auto-atribuição de todas as tarefas'
+    task assign_all: :environment do |_t, _args|
+      Issue.all.each do |i|
+        Avm::Issue::Assign.new(i).run
+      end
+    end
+
+    desc 'Verifica a seção de dependências de todas as tarefas'
+    task dependencies_section_check_all: :environment do |_t, _args|
+      Issue.where(closed_on: nil)
+           .where.not(status: Avm::Settings.issue_status_undefined).each do |i|
+        Avm::Issue::DependenciesSectionCheck.new(i).run
+      end
+    end
+
+    desc 'Verifica a ausência de motivação em todas as tarefas'
+    task motivation_check_all: :environment do |_t, _args|
+      Issue.where(closed_on: nil)
+           .where.not(status: Avm::Settings.issue_status_undefined).each do |i|
+        Avm::Issue::MotivationCheck.new(i).run
+      end
+    end
+  end
+end

data/lib/tasks/redmine_avm.rake

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+namespace :redmine_avm do
+  Rake::TestTask.new(test: 'db:test:prepare') do |t|
+    plugin_root = ::File.dirname(::File.dirname(__dir__))
+
+    t.description = 'Run plugin redmine_avm\'s tests.'
+    t.libs << 'test'
+    t.test_files = FileList["#{plugin_root}/test/**/*_test.rb"]
+    t.verbose = false
+    t.warning = false
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: redmine_avm
+version: !ruby/object:Gem::Version
+  version: 0.3.3
+platform: ruby
+authors:
+- Eduardo Henrique Bogoni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aranha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/controllers/issue_status_assigns_controller.rb
+- app/helpers/issue_status_assigns_helper.rb
+- app/models/issue_status_assign.rb
+- app/views/settings/_avm.html.erb
+- config/initializers/000_dependencies.rb
+- config/initializers/events_manager.rb
+- config/initializers/redmine_plugins_helper.rb
+- config/locales/en.yml
+- config/locales/pt-BR.yml
+- config/routes.rb
+- db/migrate/20160516164053_create_issue_status_assigns.rb
+- db/migrate/20180711164719_rename_plugin_avm_to_redmine_avm.rb
+- init.rb
+- lib/avm/issue/assign.rb
+- lib/avm/issue/dependencies_section_check.rb
+- lib/avm/issue/motivation_check.rb
+- lib/avm/issue/unblock.rb
+- lib/avm/issue/undefine.rb
+- lib/avm/listeners/issue_auto_assign.rb
+- lib/avm/listeners/issue_auto_unblock.rb
+- lib/avm/listeners/issue_auto_unblock/issue_delete.rb
+- lib/avm/listeners/issue_auto_unblock/issue_relation_delete.rb
+- lib/avm/listeners/issue_auto_unblock/issue_update.rb
+- lib/avm/listeners/issue_auto_undefine.rb
+- lib/avm/listeners/issue_auto_undefine/issue_create.rb
+- lib/avm/listeners/issue_auto_undefine/issue_relation_create.rb
+- lib/avm/listeners/issue_auto_undefine/issue_update.rb
+- lib/avm/listeners/issue_dependencies_section_check.rb
+- lib/avm/listeners/issue_motivation_check.rb
+- lib/avm/patches/issue_patch.rb
+- lib/avm/patches/test_case_patch.rb
+- lib/avm/settings.rb
+- lib/redmine_avm.rb
+- lib/redmine_avm/version.rb
+- lib/tasks/issue.rake
+- lib/tasks/redmine_avm.rake
+homepage: https://github.com/esquilo-azul/redmine_avm
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: AVM support for Redmine.
+test_files: []