redmine_nonproject_modules 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5376c3a5a50a27ab5825bf4c0d6c6cadc2d672047808792d8b7b2d5b47118443
+  data.tar.gz: b173b20f273e8236950d0ac67641e40b23a88395ad35a7157828a6c29dddc296
+SHA512:
+  metadata.gz: 3b78a4ccfc86da2be65496081ad35730be443faec2b2da9a299ceb4ae8a31e89ede3f94a8b16098484fc5be448b7835179a386c8d494a2201e31173d92ab1446
+  data.tar.gz: 57bf1adcd605ee92b9d1be876d67c279cee75b90cc49017996c955dd61c81e61a31370958de94db143ac1fdde6b73c2a4152fcc8714aae1edfc90cfb72f1ed47

data/app/assets/javascripts/redmine_nonproject_modules.js

@@ -0,0 +1 @@
+//= require 'active_scaffold'

data/app/assets/stylesheets/redmine_nonproject_modules.css

@@ -0,0 +1 @@
+@import 'active_scaffold';

data/app/controllers/group_merge_controller.rb

@@ -0,0 +1,35 @@
+class GroupMergeController < ApplicationController
+  require_permission 'group_merge'
+  helper GroupMergeHelper
+
+  def index
+    @group_merge = ::GroupMerge.new(source: ::Group.find(params[:id]))
+    build_targets_list
+  end
+
+  def check
+    @group_merge = ::GroupMerge.new(check_parameters)
+    return if @group_merge.valid?
+    build_targets_list
+    render :index
+  end
+
+  def confirm
+    @group_merge = ::GroupMerge.new(check_parameters)
+    @group_merge.save!
+    path = GroupPermission.permission?('group_permissions') ? group_permissions_path : root_path
+    redirect_to path, notice: t(:notice_successful_update)
+  end
+
+  private
+
+  def check_parameters
+    params[:group_merge].permit(:target_id).merge(source: ::Group.find(params[:id]))
+  end
+
+  def build_targets_list
+    @targets_list = Group.where.not(id: @group_merge.source.id).sorted.map do |g|
+      [g.to_s, g.id]
+    end
+  end
+end

data/app/controllers/group_permissions_controller.rb

@@ -0,0 +1,35 @@
+class GroupPermissionsController < ApplicationController
+  require_permission 'group_permissions'
+  before_action :set_group, only: [:show, :update]
+
+  def index
+    @groups = Group.sorted
+  end
+
+  def show
+    @gps = GroupPermissionsSetup.new(group: @group)
+  end
+
+  def update
+    @gps = GroupPermissionsSetup.new(gps_params)
+    if @gps.save
+      redirect_to group_permission_path(@group), notice: t(:notice_successful_update)
+    else
+      render :show
+    end
+  end
+
+  private
+
+  def gps_params
+    p = { permissions: [], group: @group }
+    if params[:group_permissions_setup] && params[:group_permissions_setup][:permissions]
+      p[:permissions] = params[:group_permissions_setup][:permissions]
+    end
+    p
+  end
+
+  def set_group
+    @group = Group.find(params[:id])
+  end
+end

data/app/helpers/group_merge_helper.rb

@@ -0,0 +1,31 @@
+module GroupMergeHelper
+  def group_merge_elements_sorted(group_merge)
+    r = group_merge.to_merge_elements.map do |x|
+      [group_merge_type_element_label(x[0]),
+       group_merge_element_label(x[0]),
+       group_merge_element_class(x)]
+    end
+    r.sort_by { |x| [x[0], x[1]] }
+  end
+
+  def group_merge_element_class(x)
+    "GroupMergeHelper_element_#{x[1]}"
+  end
+
+  def group_merge_type_element_label(element)
+    t("label_#{element.class.model_name.param_key}")
+  end
+
+  def group_merge_element_label(element)
+    m = "group_merge_#{element.class.model_name.param_key}_element_label"
+    respond_to?(m) ? send(m, element) : element.to_s
+  end
+
+  def group_merge_member_element_label(m)
+    "#{t(:label_project)}: #{m.project} (#{m.roles.to_a.join(', ')})"
+  end
+
+  def group_merge_group_permission_element_label(gp)
+    gp.permission
+  end
+end

data/app/models/group_merge.rb

@@ -0,0 +1,88 @@
+require 'virtus'
+
+class GroupMerge
+  include ActiveModel::Model
+  include Virtus.model
+  include ActiveModel::Associations
+
+  ONLY_ON_TARGET = :only_on_target
+  ONLY_ON_SOURCE = :only_on_source
+  ON_BOTH = :on_both
+
+  attribute :source_id, Integer
+  attribute :target_id, Integer
+  belongs_to :source, class_name: 'Group'
+  belongs_to :target, class_name: 'Group'
+
+  validates :source, presence: true
+  validates :target, presence: true
+
+  def [](attr)
+    send(attr)
+  end
+
+  def []=(attr, value)
+    send("#{attr}=", value)
+  end
+
+  def to_merge_elements
+    (target_elements + source_elements).uniq.map do |x|
+      [x[0], element_on_status(x)]
+    end
+  end
+
+  def save!
+    ActiveRecord::Base.transaction do
+      source_new_elements.each { |x| add_element_to_target(x[0], x[1]) }
+      source.destroy!
+    end
+  end
+
+  def associations_to_merge
+    [:users, :memberships, :permissions]
+  end
+
+  private
+
+  def element_on_status(x)
+    return ON_BOTH if target_elements.include?(x) && source_elements.include?(x)
+    return ONLY_ON_TARGET if target_elements.include?(x)
+    return ONLY_ON_SOURCE if source_elements.include?(x)
+    raise "Element is neither on source nor on target: #{x}"
+  end
+
+  def target_elements
+    @target_elements ||= elements(:target)
+  end
+
+  def source_elements
+    @source_elements ||= elements(:source)
+  end
+
+  def elements(sender)
+    associations_to_merge.flat_map do |a|
+      send(sender).send(a).map do |e|
+        [e, a]
+      end
+    end
+  end
+
+  def source_new_elements
+    source_elements.select do |x|
+      !target_elements.include?(x)
+    end
+  end
+
+  def add_element_to_target(element, association_name)
+    method = "add_#{association_name}_element_to_target"
+    if respond_to?(method, true)
+      send(method, element)
+    else
+      target.send(association_name) << element
+    end
+  end
+
+  def add_permissions_element_to_target(permission)
+    target.add_permission(permission)
+  end
+end

data/app/models/group_permission.rb

@@ -0,0 +1,106 @@
+require 'eac_ruby_utils/simple_cache'
+
+class GroupPermission < ActiveRecord::Base
+  belongs_to :group
+
+  validates :group, presence: true
+  validates :permission, presence: true, uniqueness: { scope: [:group],
+                                                       case_sensitive: false }
+
+  def permission=(value)
+    self[:permission] = Permission.sanitize_key(value)
+  end
+
+  class << self
+    def permissions
+      permissions_hash.values
+    end
+
+    def add_permission(key, options = {})
+      p = Permission.new(key, options)
+      permissions_hash[p.key] = p unless permissions_hash.key?(p.key)
+    end
+
+    def permission_description(key)
+      permission(key).description
+    end
+
+    def permission?(permission, user = false)
+      return permission_by_hash?(permission, user) if permission.is_a?(Hash)
+      permission(permission).user_has?(user || User.current)
+    end
+
+    def permission(key)
+      key = key.to_s
+      return permissions_hash[key] if permissions_hash.key?(key)
+      raise "Not found \"#{key}\" in GroupPermission::permissions"
+    end
+
+    private
+
+    def permissions_hash
+      @permissions ||= {}.with_indifferent_access
+    end
+
+    def permission_by_hash?(hash, user)
+      raise 'Hasy should have :or parameter' unless hash[:or].present?
+      ps = hash[:or].is_a?(Array) ? hash[:or] : [hash[:or]]
+      ps.any? { |p| permission?(p, user) }
+    end
+  end
+
+  class Permission
+    include ::EacRubyUtils::SimpleCache
+
+    class << self
+      def sanitize_key(k)
+        k.to_s.downcase
+      end
+    end
+
+    attr_reader :key, :dependencies
+
+    def initialize(key, options)
+      @key = self.class.sanitize_key(key)
+      @dependencies = (options[:dependencies] || []).map { |k| ::GroupPermission.permission(k) }
+    end
+
+    def description
+      I18n.t("permission_#{key}_description")
+    end
+
+    def to_s
+      key
+    end
+
+    def user_has?(user)
+      return true if user.admin
+      GroupPermission.where(group: user_groups(user), permission: depends_recursive.to_a).any?
+    end
+
+    def depends_recursive(visited = Set.new)
+      return [] if visited.include?(key)
+      r = Set.new([key])
+      visited << key
+      depends.each do |d|
+        r += d.depends_recursive(visited)
+      end
+      r
+    end
+
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+    private
+
+    def user_groups(user)
+      return [Group.anonymous] if user.anonymous?
+      [Group.anonymous, Group.non_member] + user.groups
+    end
+
+    def depends
+      ::GroupPermission.permissions.select { |p| p.dependencies.include?(self) }
+    end
+  end
+end

data/app/models/group_permissions_setup.rb

@@ -0,0 +1,20 @@
+class GroupPermissionsSetup
+  include ActiveModel::Model
+
+  attr_accessor :group
+  attr_writer :permissions
+
+  def permissions
+    @permissions ||= GroupPermission.where(group: group).pluck(:permission)
+  end
+
+  def save
+    ActiveRecord::Base.transaction do
+      GroupPermission.where(group: group).destroy_all
+      permissions.each do |p|
+        GroupPermission.create!(group: group, permission: p)
+      end
+    end
+    true
+  end
+end

data/app/views/group_merge/check.html.erb

@@ -0,0 +1,35 @@
+<%= stylesheet_link_tag 'group_merge', plugin: 'redmine_nonproject_modules' %>
+<%= title [l(:label_group_permission_plural), group_permission_path], 
+  [@group_merge.source, group_permission_path(@group_merge.source)],
+  t(:merge) %>
+<p>
+  <%= t(:group_will_be_removed, group: @group_merge.source) %>
+  <br/>
+  <%= t(:group_will_receive_elements, group: @group_merge.target) %>
+</p>
+<p>
+  <span class="GroupMergeHelper_element_only_on_target">
+    <%= t(:only_in_group, group: @group_merge.target) %>
+  </span>
+  <br/>
+  <span class="GroupMergeHelper_element_only_on_source">
+    <%= t(:only_in_group, group: @group_merge.source) %>
+  </span>
+  <br/>
+  <span class="GroupMergeHelper_element_on_both">
+    <%= t(:in_both_group) %>
+  </span>
+</p>
+<ul>
+  <% group_merge_elements_sorted(@group_merge).each do |x| %>
+    <li class="<%= x[2] %>">
+      <strong><%= x[0] %>: </strong><%= x[1] %>
+    </li>
+  <% end %>
+</ul>
+<%= labelled_form_for @group_merge, url: merge_confirm_group_path(@group_merge.source) do |f| %>
+  <p><strong>Confirma a mesclagem?</strong></p>
+  <%= f.hidden_field :target_id %>
+  <%= submit_tag t(:merge) %>
+  <%= link_to t(:button_back), merge_group_path(@group_merge.source) %>
+<% end %>

data/app/views/group_merge/index.html.erb

@@ -0,0 +1,12 @@
+<%= title [l(:label_group_permission_plural), group_permission_path], 
+  [@group_merge.source, group_permission_path(@group_merge.source)],
+  t(:merge) %>
+<%= labelled_form_for @group_merge, url: merge_check_group_path(@group_merge.source) do |f| %>
+  <%= error_messages_for 'group_merge' %>
+  <div class="box tabular">
+    <p>
+      <%= f.select :target_id, @targets_list, label: t(:field_target) %>
+    </p>
+  </div>
+  <%= submit_tag t(:merge) %>
+<% end %>

data/app/views/group_permissions/_dependencies.html.erb

@@ -0,0 +1,10 @@
+<ul>
+  <% permission.dependencies.each do |d| %>
+    <li>
+      <%= d %>
+      <% if d.dependencies.any? %>
+        <%= render partial: 'dependencies', locals: {permission: d } %>
+      <% end %>
+    </li>
+  <% end %>
+</ul>

data/app/views/group_permissions/_member_context.html.erb

@@ -0,0 +1,5 @@
+<% if GroupPermission.permission?('group_merge') %>
+  <div class="contextual">
+    <%= link_to t(:merge), merge_group_path(group) %>
+  </div>
+<% end %>

data/app/views/group_permissions/index.html.erb

@@ -0,0 +1,24 @@
+<h2><%= t(:label_group_permission_plural) %></h2>
+<table class="list groups">
+  <thead>
+    <tr>
+      <th><%= t(:field_name) %></th>
+      <% if GroupPermission.permission?('group_merge') %>
+        <th></th>
+      <% end %>
+    </tr>
+  </thead>
+  <tbody>
+    <% @groups.each do |g| %>
+      <% rowclass = cycle("odd", "even") %>
+      <tr class="<%= rowclass %>">
+        <td style="text-align: left"><%= link_to g, group_permission_path(g) %></td>
+        <% if GroupPermission.permission?('group_merge') %>
+          <td class="buttons">
+            <%= link_to t(:merge), merge_group_path(g) %>
+          </td>
+        <% end %>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/app/views/group_permissions/show.html.erb

@@ -0,0 +1,36 @@
+<%= stylesheet_link_tag 'group_permissions', plugin: 'redmine_nonproject_modules' %>
+<%= render partial: 'member_context', locals: { group: @group } %>
+<%= title [l(:label_group_permission_plural), group_permissions_path], @group.name %>
+<%= form_for(@gps, :url => group_permission_path(@group), :method => :put) do %>
+  <table class="list group_permissions_list">
+    <thead>
+      <tr>
+        <th><%= t(:field_id) %></th>
+        <th><%= t(:field_dependencies) %></th>
+        <th><%= t(:field_description) %></th>
+      </tr>
+    </thead>
+    <tbody>
+      <% GroupPermission.permissions.sort.each do |id| %>
+        <tr class="<%= cycle("odd", "even") %>">
+          <td>
+            <%= check_box_tag 'group_permissions_setup[permissions][]', id, @gps.permissions.include?(id.key),
+              :id => nil %>
+            <%= id %>
+          </td>
+          <td class="dependencies">
+            <% if id.dependencies.any? %>
+              <%= render partial: 'dependencies', locals: {permission: id } %>
+            <% else %>
+              -
+            <% end %>
+          </td>
+          <td>
+            <%= GroupPermission.permission_description(id) %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+  <p><%= submit_tag l(:button_change) %></p>
+<% end %>

data/config/initializers/000_dependencies.rb

@@ -0,0 +1,4 @@
+Redmine::Plugin.post_register :redmine_nonproject_modules do
+  # Source: https://github.com/esquilo-azul/redmine_plugins_helper
+  requires_redmine_plugin(:redmine_plugins_helper, version_or_higher: '0.5.2')
+end

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  field_target: 'Target'
+  group_will_be_removed: 'The group "%{group}" will be removed.'
+  in_both_group: In both groups.
+  label_group_permission: Group permission
+  label_group_permission_plural: Groups / Permissions
+  merge: Merge
+  group_will_receive_elements: 'The group "%{group}" will receive the following elements:'
+  only_in_group: 'Only in "%{group}".'
+  permission_group_permissions_description: Read/write access to groups' permissions.

data/config/locales/pt-BR.yml

@@ -0,0 +1,12 @@
+pt-BR:
+  field_target: 'Alvo'
+  field_dependencies: Dependências
+  group_will_be_removed: 'O grupo "%{group}" será removido.'
+  in_both_group: Em ambos os grupos.
+  label_group_permission: Permissão de grupo
+  label_group_permission_plural: Grupos / Permissões
+  merge: Mesclar
+  group_will_receive_elements: 'O grupo "%{group}" receberá os seguintes elementos:'
+  only_in_group: 'Somente em "%{group}".'
+  permission_group_permissions_description: Visualização/modificação das
+    permissões de grupo.

data/config/routes.rb

@@ -0,0 +1,6 @@
+RedmineApp::Application.routes.draw do
+  resources(:group_permissions, only: [:index, :show, :update])
+  get '/group/:id/merge', to: 'group_merge#index', as: :merge_group
+  post '/group/:id/merge_check', to: 'group_merge#check', as: :merge_check_group
+  post '/group/:id/merge_confirm', to: 'group_merge#confirm', as: :merge_confirm_group
+end

data/init.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+require 'active_scaffold'
+
+require 'redmine'
+
+require 'redmine_nonproject_modules/patches/controller_patch'
+require 'redmine_nonproject_modules/patches/group_patch'
+require 'redmine_nonproject_modules/patches/redmine/i18n_patch'
+require 'redmine_nonproject_modules/patches/redmine/menu_manager_patch'
+require 'redmine_nonproject_modules/version'
+
+Redmine::Plugin.register :redmine_nonproject_modules do
+  name 'Redmine non-project modules'
+  author ::RedmineNonprojectModules::AUTHOR
+  description ::RedmineNonprojectModules::SUMMARY
+  version ::RedmineNonprojectModules::VERSION
+  url ::RedmineNonprojectModules::HOMEPAGE
+  author_url 'https://github.com/eduardobogoni'
+
+  Redmine::MenuManager.map :admin_menu do |menu|
+    menu.push :group_permissions, { controller: 'group_permissions', action: 'index' },
+              caption: :label_group_permission_plural, after: :groups,
+              if: proc { GroupPermission.permission?('group_permissions') }
+  end
+
+  ActiveScaffold.delayed_setup = true
+end
+
+Rails.configuration.to_prepare do
+  GroupPermission.add_permission('group_permissions')
+  GroupPermission.add_permission('group_merge')
+  require_dependency 'redmine_nonproject_modules/patches/user_patch'
+end

data/lib/redmine_nonproject_modules.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'active_scaffold'
+
+module RedmineNonprojectModules
+end

data/lib/redmine_nonproject_modules/dispatcher_finder.rb

@@ -0,0 +1,32 @@
+require 'eac_ruby_utils/simple_cache'
+
+module RedmineNonprojectModules
+  # https://stackoverflow.com/questions/12088025/detect-if-application-was-started-as...
+  # https://github.com/newrelic/rpm/blob/master/lib/new_relic/local_environment.rb
+  class DispatcherFinder
+    WEBSERVER_DISPATCHERS = %w(webrick passenger).freeze
+    DISPATCHERS = WEBSERVER_DISPATCHERS
+
+    class << self
+      include ::EacRubyUtils::SimpleCache
+
+      def webserver?
+        WEBSERVER_DISPATCHERS.include?(dispatcher)
+      end
+
+      def webrick?
+        defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      end
+
+      def passenger?
+        defined?(::PhusionPassenger)
+      end
+
+      private
+
+      def dispatcher_uncached
+        DISPATCHERS.find { |d| send("#{d}?") }
+      end
+    end
+  end
+end

data/lib/redmine_nonproject_modules/patches/controller_patch.rb

@@ -0,0 +1,29 @@
+module RedmineNonprojectModules
+  module Patches
+    module ControllerPatch
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+        def require_permission(permission)
+          before_action { |c| c.before_action_require_permission(permission) }
+        end
+      end
+
+      module InstanceMethods
+        def before_action_require_permission(permission)
+          return true if GroupPermission.permission?(permission)
+          deny_access
+        end
+      end
+    end
+  end
+end
+
+unless ActionController::Base.included_modules.include?(
+  RedmineNonprojectModules::Patches::ControllerPatch
+)
+  ActionController::Base.send(:include, RedmineNonprojectModules::Patches::ControllerPatch)
+end

data/lib/redmine_nonproject_modules/patches/group_patch.rb

@@ -0,0 +1,24 @@
+module RedmineNonprojectModules
+  module Patches
+    module GroupPatch
+      def self.included(base)
+        base.class_eval do
+          has_many :permissions, class_name: 'GroupPermission', dependent: :destroy
+        end
+        base.include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def add_permission(permission)
+          permission = permission.permission if permission.is_a?(::GroupPermission)
+          return if permissions.pluck(:permission).include?(permission)
+          ::GroupPermission.create!(group: self, permission: permission)
+        end
+      end
+    end
+  end
+end
+
+unless ::Group.included_modules.include?(RedmineNonprojectModules::Patches::GroupPatch)
+  ::Group.send(:include, RedmineNonprojectModules::Patches::GroupPatch)
+end

data/lib/redmine_nonproject_modules/patches/redmine/i18n_patch.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RedmineNonprojectModules
+  module Patches
+    module Redmine
+      module I18nPatch
+        def self.included(base)
+          base.include(InstanceMethods)
+          base.alias_method_chain :l, :active_scaffold
+        end
+
+        module InstanceMethods
+          def l_with_active_scaffold(*args)
+            if (args.first.is_a?(Time) || args.first.is_a?(Date)) && args.last.is_a?(Hash)
+              ::I18n.l(args.first, args.last)
+            else
+              l_without_active_scaffold(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+x = ::Redmine::I18n
+y = ::RedmineNonprojectModules::Patches::Redmine::I18nPatch
+
+x.send(:include, y) unless x.included_modules.include?(y)

data/lib/redmine_nonproject_modules/patches/redmine/menu_manager_patch.rb

@@ -0,0 +1,91 @@
+module RedmineNonprojectModules
+  module Patches
+    module Redmine
+      module MenuManagerMapperPatch
+        def self.included(base)
+          base.send(:include, InstanceMethods)
+        end
+      end
+
+      module InstanceMethods
+        def push_controller(*args)
+          e = ControllerEntry.new(*args)
+          push(*e.build)
+          e.permissions.each do |p|
+            ::GroupPermission.add_permission(p)
+          end
+        end
+      end
+
+      class ControllerEntry
+        def initialize(controller, options = {})
+          @controller = controller.to_s
+          @options = options.with_indifferent_access
+        end
+
+        def build
+          [build_name, build_url, build_options]
+        end
+
+        def permissions
+          parse_permissions(permissions_const)
+        end
+
+        private
+
+        attr_reader :controller, :options
+
+        def build_name
+          r = controller
+          r = "#{r}_#{action}" unless action == 'index'
+          r.to_sym
+        end
+
+        def build_url
+          { controller: controller, action: action, id: id }
+        end
+
+        def build_options
+          {
+            caption: build_caption,
+            if: proc { GroupPermission.permission?(permissions_const) }
+          }
+        end
+
+        def build_caption
+          "label_#{build_name}".to_sym
+        end
+
+        def controller_class
+          Object.const_get("#{controller.camelize}Controller")
+        end
+
+        def action
+          @options[:action] || 'index'
+        end
+
+        def id
+          @options[:id]
+        end
+
+        def permissions_const
+          controller_class.const_get('PERMISSIONS')
+        end
+
+        def parse_permissions(p)
+          return parse_permissions(p.values) if p.is_a?(Hash)
+          return p.flat_map { |v| parse_permissions(v) } if p.is_a?(Enumerable)
+          [p.to_s]
+        end
+      end
+    end
+  end
+end
+
+unless ::Redmine::MenuManager::Mapper.included_modules.include?(
+  ::RedmineNonprojectModules::Patches::Redmine::MenuManagerMapperPatch
+)
+  ::Redmine::MenuManager::Mapper.send(
+    :include, ::RedmineNonprojectModules::Patches::Redmine::MenuManagerMapperPatch
+  )
+end

data/lib/redmine_nonproject_modules/patches/user_patch.rb

@@ -0,0 +1,19 @@
+module RedmineNonprojectModules
+  module Patches
+    module UserPatch
+      def self.included(base)
+        base.include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def permission?(permissions)
+          GroupPermission.permission?(permissions, self)
+        end
+      end
+    end
+  end
+end
+
+unless ::User.included_modules.include?(RedmineNonprojectModules::Patches::UserPatch)
+  ::User.send(:include, RedmineNonprojectModules::Patches::UserPatch)
+end

data/lib/redmine_nonproject_modules/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RedmineNonprojectModules
+  AUTHOR = 'Eduardo Henrique Bogoni'
+  HOMEPAGE = 'https://github.com/esquilo-azul/redmine_nonproject_modules'
+  SUMMARY = 'Support to non-project modules.'
+  VERSION = '0.2.1'
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: redmine_nonproject_modules
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- 0.2.1
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_scaffold
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.4
+- !ruby/object:Gem::Dependency
+  name: activemodel-associations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_utils
+  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
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/assets/javascripts/redmine_nonproject_modules.js
+- app/assets/stylesheets/redmine_nonproject_modules.css
+- app/controllers/group_merge_controller.rb
+- app/controllers/group_permissions_controller.rb
+- app/helpers/group_merge_helper.rb
+- app/models/group_merge.rb
+- app/models/group_permission.rb
+- app/models/group_permissions_setup.rb
+- app/views/group_merge/check.html.erb
+- app/views/group_merge/index.html.erb
+- app/views/group_permissions/_dependencies.html.erb
+- app/views/group_permissions/_member_context.html.erb
+- app/views/group_permissions/index.html.erb
+- app/views/group_permissions/show.html.erb
+- config/initializers/000_dependencies.rb
+- config/locales/en.yml
+- config/locales/pt-BR.yml
+- config/routes.rb
+- init.rb
+- lib/redmine_nonproject_modules.rb
+- lib/redmine_nonproject_modules/dispatcher_finder.rb
+- lib/redmine_nonproject_modules/patches/controller_patch.rb
+- lib/redmine_nonproject_modules/patches/group_patch.rb
+- lib/redmine_nonproject_modules/patches/redmine/i18n_patch.rb
+- lib/redmine_nonproject_modules/patches/redmine/menu_manager_patch.rb
+- lib/redmine_nonproject_modules/patches/user_patch.rb
+- lib/redmine_nonproject_modules/version.rb
+homepage: https://github.com/esquilo-azul/redmine_nonproject_modules
+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: Support to non-project modules.
+test_files: []