redmine_extensions 0.4.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c323b631909b06ccb6639635fe5a455377bb3bc52d32697219ee719af6703cb8
-  data.tar.gz: 95b3915e35e038289454287eea645278fd50aa4a082c1d8e73fd58444aabc9e9
+  metadata.gz: 83a259a0df79f133ef83c0d83a97867065e72ba53718b6021f4ea4f199350300
+  data.tar.gz: 498ecf0ad2f97992ecb43b5e9f08af3e8d7dd6e73260b1bf6539e1cce8c7f21b
 SHA512:
-  metadata.gz: 72ce72eaddf0dfb74b725161d5f10be15f14811bd0c10d7c393e4cb7d94bfe9e5270e2a04e51a0c26a72868ec6ffc69b014d2fe270423d4ba5a4b2a2dc5e43a4
-  data.tar.gz: 7f3472c8c33946ebcf5a174528bc7413b1e5a1c118f369a345fdbd69a74ea4b5840da6a22aa663948758d7d8e4cdb76ea7f5b24ae0b336bb83b62ad3cd417df8
+  metadata.gz: fadd35b5ab3c6ebfd7254b760ddbf17cd56a39fc3de03a673d15e7e2dda50ae83c4469a1e5f4d6264e87733284097d619c2181724021b8ebadf0f9d591f98f28
+  data.tar.gz: e7a1aaca2e52ec55f08178b5526aae5f82d155582683359c4f853ee7d0c3d13c79603949371cc333310d14d0af939d35d990124093ecfdef3dfeb478568dd1ee

data/README.md

@@ -0,0 +1,51 @@
+# Redmine Extensions
+
+[![pipeline status](https://git.easy.cz/redmine/redmine_extensions_gem/badges/master/pipeline.svg)](https://git.easy.cz/redmine/redmine_extensions_gem/-/commits/master)
+
+[![Latest Release](https://git.easy.cz/redmine/redmine_extensions_gem/-/badges/release.svg)](https://git.easy.cz/redmine/redmine_extensions_gem/-/releases)
+
+[![Gem Version](https://badge.fury.io/rb/redmine_extensions.svg)](http://badge.fury.io/rb/redmine_extensions)
+
+
+⚠️ This gem currently not working with Redmine at all.
+
+---
+This gem provides an extended funcionality for a Redmine project
+
+## Provided functionalities
+* EasySetting - per project settings
+* Redmine Plugin Generator
+* Redmine Entity Generator
+
+## Redmine Plugin Generator 
+
+Description:
+    The plugin generator creates stubs for a new Redmine plugin.
+    Plugin is prepared for use in Redmine and Easy Redmine as well.
+    You can use --customer flag to generate a special plugin if you can make just a few changes to code. Backup this plugin before Redmine or Easy Redmine upgrade and move back for keep you changes.
+
+Example:
+    rails g redmine_extensions:plugin NameOfNewPlugin
+      create  plugins/name_of_new_plugin/app/controllers
+      ...
+
+Help:
+     rails g redmine_extensions:plugin --help
+
+
+## Redmine Entity Generator
+
+Description:
+    The entity generator creates new entity for Redmine plugin.
+    New entity is prepared for use in Redmine and Easy Redmine as well.
+
+Example:
+    rails g redmine_extensions:entity NameOfNewPlugin Post
+      create  plugins/name_of_new_plugin/app/controllers
+      ...
+
+Help:
+    rails g redmine_extensions:entity --help
+
+## Licence
+This is published under GPL-2 license.

data/app/assets/javascripts/redmine_extensions/redmine_extensions.js

@@ -83,6 +83,7 @@ EasyGem.schedule.require(function () {
       render_item: function (ul, item) {
         return $("<li>")
             .data("item.autocomplete", item)
+            .attr('item_id', item.id)
             .text(item.label)
             .appendTo(ul);
       },

data/app/helpers/redmine_extensions/application_helper.rb

@@ -14,7 +14,7 @@ module RedmineExtensions
 
     # -------= Rendering and presenting methods =-------
 
-    def present(model, options={}, &block)
+    def present(model, options = {}, &block)
       if model.is_a?(RedmineExtensions::BasePresenter)
         presenter = model.update_options(options.merge(view_context: self))
       else
@@ -31,11 +31,12 @@ module RedmineExtensions
 
     # hide elements for issues and users
     def detect_hide_elements(uniq_id, user = nil, default = true)
-      return ''.html_safe if uniq_id.blank?
-      return 'style="display:none"'.html_safe if !toggle_button_expanded?(uniq_id, user, default)
+      return if uniq_id.blank?
+
+      'style="display:none"'.html_safe if !toggle_button_expanded?(uniq_id, user, default)
     end
 
-    def url_to_entity(entity, options={})
+    def url_to_entity(entity, options = {})
       m = "url_to_#{entity.class.name.underscore}".to_sym
       if respond_to?(m)
         send(m, entity, options)
@@ -87,7 +88,7 @@ module RedmineExtensions
       render(:partial => 'easy_entity_assignments/assignments_container', :locals => {
         :entity => entity,
         :query => query, :project => project,
-        :entities => entities, :entities_count => entities_count, :options => options})
+        :entities => entities, :entities_count => entities_count, :options => options })
     end
 
     def entity_css_icon(entity_or_entity_class)
@@ -116,7 +117,7 @@ module RedmineExtensions
         else
           content_or_options_with_block
         end
-      html_options.reverse_merge!({type:'application/javascript'})
+      html_options.reverse_merge!({ type: 'application/javascript' })
       priority = html_options.delete(:priority) || 0
       content = "  EasyGem.schedule.late(function(){#{content}  }, #{priority});"
 
@@ -139,27 +140,16 @@ module RedmineExtensions
       javascript_tag content.html_safe, html_options
     end
 
-    def get_jasmine_tags
-      tags = params[:jasmine]
-      return [] if tags == 'true'
-      if tags.is_a?(String)
-        [tags.to_sym]
-      elsif tags.is_a?(Array)
-        tags.map &:to_sym
-      else
-        []
-      end
-    end
-
     def easy_avatar_url(user = nil)
+      return avatar_url(user) if respond_to?(:avatar_url)
+
       user ||= User.current
-      result = if Setting.gravatar_enabled?
-        options = {:ssl => (request && request.ssl?), :default => Setting.gravatar_default}
-        email = nil
-        if user.respond_to?(:mail)
-          email = user.mail
+      if Setting.gravatar_enabled?
+        options = { ssl: (request&.ssl?), default: Setting.gravatar_default }
+        email = if user.respond_to?(:mail)
+          user.mail
         elsif user.to_s =~ %r{<(.+?)>}
-          email = $1
+          $1
         end
         email ? gravatar_url(email, options) : ''
       elsif user.easy_avatar_url.present?
@@ -167,7 +157,6 @@ module RedmineExtensions
       elsif user.respond_to?(:easy_avatar) && (av = user.easy_avatar).present? && (img_url = av.image.url(:small))
         get_easy_absolute_uri_for(img_url).to_s
       end
-      result
     end
 
     # ==== Options
@@ -180,13 +169,14 @@ module RedmineExtensions
     # * <tt>remember: false</tt> - This disable remember function of toggle container
     # ** Aliases for this options are: ajax_call
     #
-    def render_module_easy_box(id, heading, options = {}, &block) # with fallback to old
+    def render_module_easy_box(id, heading, options = {}, &block)
+      # with fallback to old
       options[:toggle] = true unless options.key?(:toggle)
       options[:remember] = options.delete(:ajax_call) if options.key?(:ajax_call)
       options[:collapsible] = !options.delete(:no_expander) if options.key?(:no_expander)
 
       renderer = EasyBoxRenderer.new(self, id, heading, options)
-      renderer.content = capture {yield renderer}
+      renderer.content = capture { yield renderer }
 
       renderer.render
     end
@@ -247,8 +237,9 @@ module RedmineExtensions
       end
 
       def render
-        view.render({partial: 'common/collapsible_module_layout', locals: {renderer: self, content: content}} )
+        view.render({ partial: 'common/collapsible_module_layout', locals: { renderer: self, content: content } })
       end
+
       private
 
       def css_classes
@@ -257,9 +248,9 @@ module RedmineExtensions
           @css_classes = css_class
         else
           @css_classes = {
-              container: css_class,
-              heading: css_class,
-              content: css_class
+            container: css_class,
+            heading: css_class,
+            content: css_class
           }
         end
       end
@@ -287,7 +278,7 @@ module RedmineExtensions
     # * +rootElement+ - Has sence only if jsonpath is used for available values. It tells if the json response has values wrapped under root element.
     #                     For response like <tt>{projects: [[<name>, <id>], [<name2>, <id2>]]}</tt> user option <tt>rootElement: 'projects'</tt>
     def autocomplete_field_tag(name, jsonpath_or_array, selected_values, options = {})
-      options.reverse_merge!({select_first_value: false, load_immediately: false, preload: true, multiple: true, combo: false})
+      options.reverse_merge!(select_first_value: false, load_immediately: false, preload: true, multiple: true, combo: false)
       options[:id] ||= sanitize_to_id(name)
 
       selected_values ||= []
@@ -298,9 +289,9 @@ module RedmineExtensions
         source = "'#{jsonpath_or_array}'"
       end
 
-      content_tag(:span, :class => 'easy-multiselect-tag-container') do
-        search_field_tag('', '', (options[:html_options] || {}).merge(id: options[:id])) +
-          late_javascript_tag("$('##{options[:id]}').easymultiselect({multiple: #{options[:multiple]}, rootElement: #{options[:rootElement].to_json}, inputName: '#{name}', preload: #{options[:preload]}, combo: #{options[:combo]}, source: #{source}, selected: #{selected_values.to_json}, select_first_value: #{options[:select_first_value]}, load_immediately: #{options[:load_immediately]}, autocomplete_options: #{(options[:jquery_auto_complete_options]||{}).to_json} });")
+      content_tag(:span, class: 'easy-multiselect-tag-container', data: { cy: "container_old_autocomplete--#{name}" }) do
+        search_field_tag('', '', (options[:html_options] || {}).merge(id: options[:id], data: { cy: "search_old_autocomplete--#{name}" })) +
+          late_javascript_tag("$('##{options[:id]}').easymultiselect({multiple: #{options[:multiple]}, rootElement: #{options[:rootElement].to_json}, inputName: '#{name}', preload: #{options[:preload]}, combo: #{options[:combo]}, source: #{source}, selected: #{selected_values.to_json}, select_first_value: #{options[:select_first_value]}, load_immediately: #{options[:load_immediately]}, autocomplete_options: #{(options[:jquery_auto_complete_options] || {}).to_json} });")
       end
     end
 
@@ -323,7 +314,7 @@ module RedmineExtensions
     #           <input type="hidden" name="issue[tag_ids][]" value="#{@issue.tag_ids.second}" />
     #         ...(wraping service tags end)
     #        </span>
-    def autocomplete_field(object_name, method, choices, options={}, html_options={})
+    def autocomplete_field(object_name, method, choices, options = {}, html_options = {})
       Tags::AutocompleteField.new(object_name, method, self, choices, options, html_options).render
     end
 

data/app/views/common/_collapsible_module_layout.html.erb

@@ -1,8 +1,26 @@
 <div class="module box <%= renderer.container_class %>"<%=raw renderer.saving_state_enabled? && %Q{ data-toggle="#{renderer.id}"} || nil %>>
   <%= content_tag(:div, class: 'module-heading ' + renderer.heading_class, onclick: (renderer.collapsible? && 'EasyToggler.toggle(this.nextElementSibling, event)' || nil)) do %>
-    <%= content_tag(:span, ' ', class: 'expander module-toggler') if renderer.collapsible? %>
     <%= content_tag(renderer.heading_tag, renderer.heading, class: renderer.icon) %>
-    <%= content_tag(:span, renderer.heading_links, class: 'module-heading-links') if renderer.heading_links.presence %>
+    <% if renderer.heading_links.presence %>
+      <div class="module-heading-links">
+        <a class="module-heading-links__control icon-more-horiz control--<%= renderer.id %>" title="<%= l(:button_heading_links) %>" aria-label="<%= l(:button_heading_links) %>" role="button"></a>
+        <ul class="module-heading-links__tooltip tooltip tooltip--<%= renderer.id %>">
+          <%= renderer.heading_links %>
+          <% if renderer.collapsible? -%>
+            <li><span href="#" class="icon-chevron-up module__expander" data-cy="expander__toggle--module" title="Expander" aria-label="Expander" role="button">&nbsp;</span></li>
+          <% end -%>
+        </ul>
+        <script>
+          EASY.schedule.require(function(){
+            $('.control--<%= renderer.id %>').toggleable({
+              observer: EASY.defaultClickObserver,
+              content: $('.tooltip--<%= renderer.id %>')
+            })},function () {
+            return EASY.defaultClickObserver;
+          })
+        </script>
+      </div>
+    <% end -%>
   <% end if renderer.heading.present? %>
   <div class="module-content" id="<%= renderer.id %>"<%=raw renderer.collapsed? && %q{ style="display:none"} || nil %>>
     <%= content -%>

data/app/views/easy_front_end/_easy_front_end.html.erb

@@ -1,22 +1,4 @@
 <% content_for :header_tags do %>
-  <%=
-    if params['combine_by_pipeline'].nil?
-      if Rails.env.development? && ENV['DART'] == '1'
-        javascript_include_tag('dart/localhost', plugin: plugin, defer: true)
-      else
-        javascript_include_tag("#{plugin}.dart", defer: true)
-      end
-    else
-      if params['combine_by_pipeline'] == 'false'
-        #javascript_include_tag('dart/debug', plugin: plugin, defer: true)
-        if ENV['DART'] == '1'
-          javascript_include_tag('dart/localhost', plugin: plugin, defer: true)
-        end
-      else
-        javascript_include_tag("#{plugin}.dart", defer: true)
-      end
-    end
-  %>
 
   <%
     standard_lang_files = [
@@ -87,6 +69,6 @@
 
   %>
   <script>
-    window.frontEndCommons = "<%= escape_javascript(front_end_commons.to_json.html_safe) %>";
+    window.frontEndCommons = "<%= j(front_end_commons.to_json.html_safe) %>";
   </script>
 <% end %>

data/db/migrate/20150705172511_create_easy_settings.rb

@@ -1,4 +1,4 @@
-class CreateEasySettings < RedmineExtensions::Migration
+class CreateEasySettings < ActiveRecord::Migration[4.2]
   def up
     if table_exists?(:easy_settings)
       add_column(:easy_settings, :type, :string, null: true) unless column_exists?(:easy_settings, :type)

data/db/migrate/20160519161300_create_entity_assignments.rb

@@ -1,4 +1,4 @@
-class CreateEntityAssignments < RedmineExtensions::Migration
+class CreateEntityAssignments < ActiveRecord::Migration[4.2]
   def self.up
     unless table_exists?(:easy_entity_assignments)
       create_table :easy_entity_assignments do |t|

data/db/migrate/20190206121100_remove_foreign_key_from_easy_settings.rb

@@ -1,4 +1,4 @@
-class RemoveForeignKeyFromEasySettings < RedmineExtensions::Migration
+class RemoveForeignKeyFromEasySettings < ActiveRecord::Migration[4.2]
   def up
     begin
       remove_foreign_key :easy_settings, :projects

data/lib/generators/redmine_extensions/entity/templates/_sidebar.html.erb.erb

@@ -2,7 +2,7 @@
   <%% if @<%= model_name_underscored %> && !@<%= model_name_underscored %>.new_record? %>
     <%%= content_tag(:li, link_to(l(:button_edit), edit_polymorphic_path([@project, @<%= model_name_underscored %>]), title: l(:button_edit), class: 'icon icon-edit button')) %>
   <%% end %>
-  <%% unless @<%= model_name_underscored %> %>
+  <%% if @<%= model_name_underscored %>.nil? %>
     <%%= content_tag(:li, link_to(l(:button_<%= model_name_underscored %>_new), new_polymorphic_path([@project, :<%= model_name_underscored %>]), title: l(:title_<%= model_name_underscored %>_new), class: 'icon icon-add button button-positive')) %>
   <%% end %>
   <%%= content_tag(:li, link_to(l(:label_<%= model_name_pluralize_underscored %>), polymorphic_path([@project, :<%= model_name_pluralize_underscored %>], set_filter: '1'), title: l(:label_<%= model_name_pluralize_underscored %>), class: 'icon icon-folder button')) %>

data/lib/generators/redmine_extensions/entity/templates/show.html.erb.erb

@@ -24,7 +24,7 @@
       <hr />
     <%%= render partial: 'redmine_extensions/custom_field_rows', locals: { custom_field_values: @<%= model_name_underscored %>.visible_custom_field_values } %>
     <%- end -%>
-    <%%= call_hook(:view_<%= model_name_pluralize_underscored %>_show_details_bottom, :<%= model_name_underscored%>: @<%= model_name_underscored %>) %>
+    <%%= call_hook(:view_<%= model_name_pluralize_underscored %>_show_details_bottom, <%= model_name_underscored%>: @<%= model_name_underscored %>) %>
   </table>
 <%- if description_column? -%>
   <%% if !@<%= model_name_underscored %>.<%= description_column %>.blank? %>

data/lib/redmine_extensions/engine.rb

@@ -8,10 +8,9 @@ require_relative './query_output'
 
 module RedmineExtensions
   class Engine < ::Rails::Engine
-
     config.generators do |g|
-      g.test_framework      :rspec,        :fixture => false
-      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.test_framework      :rspec,        fixture: false
+      g.fixture_replacement :factory_girl, dir: 'spec/factories'
       g.assets false
       g.helper false
     end
@@ -23,14 +22,10 @@ module RedmineExtensions
       if config.respond_to?(:assets)
         config.assets.precompile << 'redmine_extensions/applications.js'
         config.assets.precompile << 'redmine_extensions/blocking.js'
-        unless Rails.env.production?
-          config.assets.precompile << 'redmine_extensions/jasmine_lib/jasmine_lib.js'
-          config.assets.precompile << 'redmine_extensions/jasmine.css'
-        end
       end
     end
 
-    #config.to_prepare goes after Reloader.to_prepare
+    # config.to_prepare goes after Reloader.to_prepare
     RedmineExtensions::Reloader.to_prepare do
       RedmineExtensions::QueryOutput.register_output RedmineExtensions::QueryOutputs::ListOutput
       RedmineExtensions::QueryOutput.register_output RedmineExtensions::QueryOutputs::TilesOutput
@@ -39,7 +34,7 @@ module RedmineExtensions
       ApplicationController.include RedmineExtensions::RenderingHelper
     end
 
-    initializer 'redmine_extensions.initialize' do |app|
+    initializer 'redmine_extensions.initialize' do |_app|
       ActionDispatch::Routing::RouteSet::Generator.prepend RedmineExtensions::RailsPatches::RouteSetGeneratorPatch
     end
 
@@ -52,17 +47,15 @@ module RedmineExtensions
       if true
         js_dir = app.root.join('public', 'javascripts', 'redmine_extensions')
         FileUtils.mkdir(js_dir) unless File.directory?(js_dir)
-        Dir.glob( root.join('app', 'assets', 'javascripts', 'redmine_extensions', '*.js') ) do |js_file|
-          begin
-            FileUtils.cp(js_file, app.root.join('public', 'javascripts', 'redmine_extensions'))
-          rescue
-          end
+        Dir.glob(root.join('app', 'assets', 'javascripts', 'redmine_extensions', '*.js')) do |js_file|
+          FileUtils.cp(js_file, app.root.join('public', 'javascripts', 'redmine_extensions'))
+        rescue StandardError
         end
       end
     end
 
     # include helpers
-    initializer 'redmine_extensions.rails_patching', before: :load_config_initializers do |app|
+    initializer 'redmine_extensions.rails_patching', before: :load_config_initializers do |_app|
       ActiveSupport.on_load(Rails::VERSION::MAJOR >= 5 ? :action_controller_base : :action_controller) do
         helper RedmineExtensions::ApplicationHelper
         # helper RedmineExtensions::EasyQueryHelper
@@ -78,17 +71,10 @@ module RedmineExtensions
     initializer 'redmine_extensions.initialize_easy_plugins', after: :load_config_initializers do
       require_relative './hooks'
 
-      unless Redmine::Plugin.installed?(:easy_extensions)
-        ActiveSupport.run_load_hooks(:easyproject, self)
-      end
+      ActiveSupport.run_load_hooks(:easyproject, self) unless Redmine::Plugin.installed?(:easy_extensions)
 
       require_relative './easy_entity_formatters/easy_entity_formatter'
     end
 
-    # initializer :add_html_formatting do |app|
-    #   require_relative "./html_formatting"
-    #   Redmine::WikiFormatting.register(:HTML, RedmineExtensions::HTMLFormatting::Formatter, RedmineExtensions::HTMLFormatting::Helper)
-    # end
-
   end
 end

data/lib/redmine_extensions/hooks.rb

@@ -1,10 +1,6 @@
 module RedmineExtensions
   class Hooks < Redmine::Hook::ViewListener
 
-    if Rails.env.development?
-      render_on :view_layouts_base_body_bottom, partial: 'redmine_extensions/development_mode'
-    end
-
     if defined?(EasyExtensions)
       if EasyExtensions.try(:deferred_js)
 
@@ -23,9 +19,6 @@ module RedmineExtensions
           context[:template].require_asset('redmine_extensions/application')
         end
       end
-      if Rails.env.development? || Rails.env.test?
-        render_on :view_layouts_base_html_head, partial: 'redmine_extensions/jasmine'
-      end
     else
       ### JAVASCRIPTS IN REDMINE ###
       def view_layouts_base_html_head(context = {})
@@ -42,8 +35,7 @@ module RedmineExtensions
           javascript_include_tag('redmine_extensions/easy_togglers') +
           javascript_include_tag('redmine_extensions/jquery.entityarray') +
           javascript_include_tag('redmine_extensions/render_polyfill') +
-          javascript_include_tag('redmine_extensions/redmine_extensions') +
-          (context[:controller].send(:render_to_string, partial: 'redmine_extensions/jasmine') if Rails.env.development? || Rails.env.test?)
+          javascript_include_tag('redmine_extensions/redmine_extensions')
       end
     end
 

data/lib/redmine_extensions/migration.rb

@@ -6,4 +6,4 @@ module RedmineExtensions
     class Migration < ActiveRecord::Migration
     end
   end
-end
+end

data/lib/redmine_extensions/patch_manager.rb

@@ -47,14 +47,14 @@ module RedmineExtensions
     # =>          :after => 'Project'
     # =>          :last
     # =>          :if => Proc.new{ Object.const_defined?(:EasyBudgetSheetQuery) }
-    def self.register_patch(original_klasses_to_patch, patching_module, options={})
+    def self.register_patch(original_klasses_to_patch, patching_module, options = {})
       return if @@reloading_code
 
       options ||= {}
 
       begin
         const = patching_module.constantize
-        @@patches_locations[patching_module] = const.methods(false).map{|m| const.method(m) }.first.source_location.first
+        @@patches_locations[patching_module] = const.methods(false).map { |m| const.method(m) }.first.source_location.first
       rescue
         # [0] is register_*_patch
         from_location = caller_locations(2..2).first
@@ -71,7 +71,7 @@ module RedmineExtensions
         raise ArgumentError, 'EasyPatchManager->register_patch: The \'original_klass_to_patch\' have to be a string or array of strings!'
       end
 
-      raise ArgumentError, "EasyPatchManager->register_patch: The \'patching_module\' (#{patching_module}) already exists!" if EasyPatch.all_patching_modules.include?( patching_module )
+      raise ArgumentError, "EasyPatchManager->register_patch: The \'patching_module\' (#{patching_module}) already exists!" if EasyPatch.all_patching_modules.include?(patching_module)
 
       if options[:section]
         section = options.delete(:section).to_sym
@@ -81,47 +81,47 @@ module RedmineExtensions
       raise ArgumentError, "EasyPatchManager->register_patch: The section (#{section}) must be one of x#{@@registered_patches.keys.join(', ')}x " unless @@registered_patches.key?(section)
 
       original_klasses_to_patch.each do |original_klass_to_patch|
-        pcollection = @@registered_patches[section].move_and_get_or_insert( original_klass_to_patch, options )
+        pcollection = @@registered_patches[section].move_and_get_or_insert(original_klass_to_patch, options)
         pcollection << EasyPatch.new(original_klass_to_patch, patching_module, options)
       end
     end
-    private_class_method :register_patch
 
+    private_class_method :register_patch
 
-    def self.register_ruby_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :ruby}.merge(options))
+    def self.register_ruby_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { section: :ruby }.merge(options))
     end
 
-    def self.register_rails_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :rails}.merge(options))
+    def self.register_rails_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { section: :rails }.merge(options))
     end
 
-    def self.register_redmine_plugin_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :redmine_plugins}.merge(options))
+    def self.register_redmine_plugin_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :redmine_plugins }.merge(options))
     end
 
-    def self.register_other_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :others}.merge(options))
+    def self.register_other_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :others }.merge(options))
     end
 
-    def self.register_concern_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :concerns}.merge(options))
+    def self.register_concern_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :concerns }.merge(options))
     end
 
-    def self.register_controller_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :controllers}.merge(options))
+    def self.register_controller_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :controllers }.merge(options))
     end
 
-    def self.register_helper_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :helpers}.merge(options))
+    def self.register_helper_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :helpers }.merge(options))
     end
 
-    def self.register_model_patch(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :models}.merge(options))
+    def self.register_model_patch(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :models }.merge(options))
     end
 
-    def self.register_patch_to_be_first(original_klass_to_patch, patching_module, options={})
-      register_patch(original_klass_to_patch, patching_module, {:section => :force_first}.merge(options))
+    def self.register_patch_to_be_first(original_klass_to_patch, patching_module, options = {})
+      register_patch(original_klass_to_patch, patching_module, { :section => :force_first }.merge(options))
     end
 
     def self.register_easy_page_helper(*helper_or_helpers_klass_name)
@@ -208,28 +208,28 @@ module RedmineExtensions
       end
 
       def [](name)
-        pcollection = @patches_collections.detect{|patch_col| patch_col.name == name }
+        pcollection = @patches_collections.detect { |patch_col| patch_col.name == name }
       end
 
       def include_patch?(name)
-        !!@patches_collections.detect{|patch_col| patch_col.name == name }
+        !!@patches_collections.detect { |patch_col| patch_col.name == name }
       end
 
-      def move_and_get_or_insert( name, options )
-        pcollection = @patches_collections.detect{|patch_col| patch_col.name == name }
-        founded_order = find_order( options )
+      def move_and_get_or_insert(name, options)
+        pcollection = @patches_collections.detect { |patch_col| patch_col.name == name }
+        founded_order = find_order(options)
         if pcollection
           if founded_order
             pcollection.order = founded_order
             update_order_by(pcollection)
           end
         else
-          pcollection = insert( name, founded_order )
+          pcollection = insert(name, founded_order)
         end
         pcollection
       end
 
-      def find_order( options )
+      def find_order(options)
         if options.delete(:first)
           return 1
         elsif before = options.delete(:before)
@@ -240,7 +240,7 @@ module RedmineExtensions
               actual = nil
               before_patch = self[before_class_name]
               actual = before_patch.order if before_patch
-              if actual && ( !min || actual < min )
+              if actual && (!min || actual < min)
                 min = actual
               end
             end
@@ -277,7 +277,7 @@ module RedmineExtensions
 
       private
 
-      def push_back( collection )
+      def push_back(collection)
         # => ambitious, if it is private method...
         # raise ArgumentError, "Section already contains a collection #{collection.name}" if @patches_collections.detect{ |coll| collection.name == coll.name }
         @patches_collections << collection
@@ -287,16 +287,16 @@ module RedmineExtensions
         @last_order += 1
       end
 
-      def insert( name, order = nil )
+      def insert(name, order = nil)
         final_order = order || last_order
-        collection = EasyPatchesCollection.new( name, final_order )
-        push_back( collection )
-        update_order_by( collection ) if order
+        collection = EasyPatchesCollection.new(name, final_order)
+        push_back(collection)
+        update_order_by(collection) if order
         collection
       end
 
-      def update_order_by( collection )
-        @patches_collections.select {|patch_coll| ( patch_coll.name != collection.name ) && ( patch_coll.order >= collection.order ) }.each do |col|
+      def update_order_by(collection)
+        @patches_collections.select { |patch_coll| (patch_coll.name != collection.name) && (patch_coll.order >= collection.order) }.each do |col|
           col.order = col.order + 1
         end
         @patches_collections.sort!
@@ -347,7 +347,6 @@ module RedmineExtensions
 
     end
 
-
     class EasyPatch
 
       def self.all_patching_modules
@@ -374,9 +373,7 @@ module RedmineExtensions
       end
 
       def apply_patch
-        if (cond = @options[:if]) && cond.respond_to?(:call)
-          return unless cond.call
-        end
+        return if (cond = @options[:if]) && cond.respond_to?(:call) && !cond.call
 
         pm_klass = easy_constantize(patching_module)
         # pm_klass.class_eval { unloadable }
@@ -392,10 +389,13 @@ module RedmineExtensions
             oktp_klass.include pm_klass
           end
         end
+      rescue NameError => e
+        patch_location = Module.const_source_location(patching_module)
+        raise NameError, "#{e.message} in #{patch_location}"
       end
 
       def easy_constantize(name)
-        const = name.constantize
+        name.constantize
       rescue NameError
         if RedmineExtensions::PatchManager.patches_locations.has_key?(name)
           RedmineExtensions::PatchManager.with_reloading_code do