Merge pull request #14 from ishikawa999/develop

Merge develop branch v0.01.0

Author: ishikawa999

.circleci/config.yml

@@ -0,0 +1,41 @@
+version: 2.1
+
+orbs:
+  redmine: agileware-jp/[email protected]
+
+workflows:
+  version: 2
+  test:
+    jobs:
+      - redmine/download:
+          name: redmine40-download
+          redmine_version: '4.0.4'
+      - redmine/download:
+          name: redmine34-download
+          redmine_version: '3.4.11'
+      - redmine/download:
+          name: redmine33-download
+          redmine_version: '3.3.9'
+      - redmine/download:
+          name: redmine32-download
+          redmine_version: '3.2.9'
+      - redmine/test:
+          name: redmine40
+          before-setup: [redmine/generate_database_yml-pg]
+          executor: redmine/ruby-26-pg
+          requires: [redmine40-download]
+      - redmine/test:
+          name: redmine34
+          before-setup: [redmine/generate_database_yml-pg]
+          executor: redmine/ruby-24-pg
+          requires: [redmine34-download]
+      - redmine/test:
+          name: redmine33
+          before-setup: [redmine/generate_database_yml-pg]
+          executor: redmine/ruby-23-pg
+          requires: [redmine33-download]
+      - redmine/test:
+          name: redmine32
+          before-setup: [redmine/generate_database_yml-pg]
+          executor: redmine/ruby-22-pg
+          requires: [redmine32-download]

35_change_load_order_locales.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+p = Redmine::Plugin.find(:redmine_message_customize)
+custom_locales = Dir.glob(File.join(p.directory, 'config', 'locales', 'custom_messages', '*.rb'))
+Rails.application.config.i18n.load_path = (Rails.application.config.i18n.load_path - custom_locales + custom_locales)

Gemfile

@@ -0,0 +1,3 @@
+if dependencies.detect { |d| d.name == 'rails' && d.requirement.to_s.include?('4.2.') }
+  gem 'rails_kwargs_testing', group: :test
+end

README.md

@@ -3,6 +3,17 @@
 This is a plugin for Redmine.  
 This plugin changes the translation of the wording on the screen defined in "config/locales/*.yml" in the admin view.
 
+## Install
+
+```
+$ cd /your/path/redmine
+$ git clone https://github.com/ishikawa999/redmine_message_customize.git plugins/redmine_message_customize
+$ cp plugins/redmine_message_customize/35_change_load_order_locales.rb config/initializers/35_change_load_order_locales.rb
+$ # redmine restart
+```
+
+:warning: In order to customize messages of other plugins, it is necessary to copy redmine_message_customize/35_change_load_order_locales.rb into redmine/config/initializers.
+
 ## Usage
 
 * 1: Open setting page  
@@ -15,17 +26,13 @@ Administration > Message customize
 * 2-2: YAML mode tab
 <kbd><img src="https://github.com/ishikawa999/redmine_message_customize/blob/images/yaml_mode.png" /></kbd>
 
-## Install
-
-```
-$ cd /your/path/redmine/plugins
-$ git clone https://github.com/ishikawa999/redmine_message_customize.git
-$ # redmine restart
-```
-
 ## Run test
 
 ```
 $ cd /your/path/redmine
-$ bundle exec rake test TEST=plugins/redmine_message_customize/test RAILS_ENV=test
+$ bundle exec rake redmine:plugins:test NAME=redmine_message_customize RAILS_ENV=test
 ```
+
+## CircleCI test
+
+https://circleci.com/gh/ishikawa999/redmine_message_customize

app/controllers/custom_message_settings_controller.rb

@@ -1,11 +1,15 @@
 class CustomMessageSettingsController < ApplicationController
   layout 'admin'
   before_action :require_admin, :set_custom_message_setting, :set_lang
-  require_sudo_mode :edit, :update, :toggle_enabled
+  require_sudo_mode :edit, :update, :toggle_enabled, :default_messages
 
   def edit
   end
 
+  def default_messages
+    @file_path = Rails.root.join('config', 'locales', "#{@lang}.yml")
+  end
+
   def update
     languages = @setting.using_languages
 
@@ -18,12 +22,16 @@ def update
     if @setting.errors.blank?
       flash[:notice] = l(:notice_successful_update)
       languages += @setting.using_languages
-      CustomMessageSetting.reload_translations!(languages)
+      MessageCustomize::Locale.reload!(languages)
 
       redirect_to edit_custom_message_settings_path(tab: params[:tab], lang: @lang)
     else
       render :edit
     end
+
+  # Catch an exception that occurs when the value field capacity is exceeded (ActiveRecord::ValueTooLong)
+  rescue ActiveRecord::StatementInvalid
+    render_error l(:error_value_too_long)
   end
 
   def toggle_enabled
@@ -37,6 +45,7 @@ def toggle_enabled
   end
 
   private
+
   def set_custom_message_setting
     @setting = CustomMessageSetting.find_or_default
   end
@@ -46,6 +55,6 @@ def setting_params
   end
 
   def set_lang
-    @lang = CustomMessageSetting.find_language(params[:lang].presence || User.current.language.presence || 'en')
+    @lang = MessageCustomize::Locale.find_language(params[:lang].presence || User.current.language.presence || 'en')
   end
-end
+end

app/helpers/custom_message_settings_helper.rb

@@ -1,13 +1,16 @@
 module CustomMessageSettingsHelper
   def available_message_options(setting, lang)
     options = [['', '']] +
-                CustomMessageSetting.available_messages(lang).map{|k, v| ["#{k}: #{v}", k]}
+                CustomMessageSetting.flatten_hash(MessageCustomize::Locale.available_messages(lang))
+                .select{|_k, v| v.is_a?(String)}
+                .map{|k, v| ["#{k}: #{v}", k]}
 
     options_for_select(options, disabled: setting.custom_messages_to_flatten_hash(lang).keys)
   end
 
   def normal_mode_input_fields(setting, lang)
-    return '' if setting.value[:custom_messages].is_a?(String) || setting.value[:custom_messages].blank?
+    return '' if setting.custom_messages.is_a?(String) || setting.custom_messages.blank?
+
     content = ActiveSupport::SafeBuffer.new
     custom_messages_hash = setting.custom_messages_to_flatten_hash(lang.to_s)
     custom_messages_hash.each do |k, v|
@@ -19,4 +22,12 @@ def normal_mode_input_fields(setting, lang)
     end
     content
   end
+
+  def open_default_messages_window_link(lang)
+    link_to l(:label_default_messages),
+            default_messages_custom_message_settings_path(lang: lang),
+            class: 'icon icon-file text-plain',
+            onclick: "window.open(this.href,'redmine_message_customize_plugin-default_messages', 'height=800, width=500');return false;",
+            id: 'default-messages-link'
+  end
 end

app/models/custom_message_setting.rb

@@ -1,5 +1,5 @@
 class CustomMessageSetting < Setting
-  validate :add_errors, :convertible_to_yaml,
+  validate :convertible_to_yaml,
            :custom_message_languages_are_available, :custom_message_keys_are_available
 
   def self.find_or_default
@@ -11,30 +11,23 @@ def enabled?
   end
 
   def custom_messages(lang=nil, check_enabled=false)
-    messages = self.value[:custom_messages] || self.value['custom_messages']
-    if lang.present?
-      messages = messages[self.class.find_language(lang)]
-    end
+    return {} if check_enabled && !self.enabled?
 
-    if messages.blank? || (check_enabled && !self.enabled?)
-      {}
-    else
-      messages
-    end
+    messages = raw_custom_messages
+    messages = messages[lang.to_s] if lang.present?
+    messages || {}
   end
 
   def custom_messages_to_flatten_hash(lang=nil)
     self.class.flatten_hash(custom_messages(lang))
   end
 
   def custom_messages_to_yaml
-    messages = self.custom_messages
-    if messages.blank?
-      ''
-    elsif messages.is_a?(Hash)
-      YAML.dump(messages)
+    messages = custom_messages
+    if messages.is_a?(Hash)
+      messages.present? ? YAML.dump(messages) : ''
     else
-      messages
+      raw_custom_messages
     end
   end
 
@@ -49,27 +42,20 @@ def update_with_custom_messages(custom_messages, lang)
         original_custom_messages
       end
 
-    self.value = {custom_messages: (messages.present? ? messages : {})}
+    self.custom_messages = messages
     self.save
   end
 
   def update_with_custom_messages_yaml(yaml)
-    begin
-      messages = YAML.load(yaml)
-      @errs = {base: l(:error_invalid_yaml_format) } if !messages.is_a?(Hash) && messages.present?
-      self.value = {custom_messages: (messages.present? ? messages : {})}
-    rescue => e
-      @errs = {base: e.message}
-      self.value = {custom_messages: yaml}
-    end
+    self.custom_messages = yaml
     self.save
   end
 
   def toggle_enabled!
-    self.value = self.value.deep_merge({enabled: (!self.enabled?).to_s})
+    self.value = self.value.merge({enabled: (!self.enabled?).to_s})
 
     if result = self.save
-      self.class.reload_translations!(self.using_languages)
+      MessageCustomize::Locale.reload!(self.using_languages)
     end
     result
   end
@@ -83,21 +69,13 @@ def using_languages
     end
   end
 
-  def self.available_messages(lang)
-    messages = I18n.backend.send(:translations)[self.find_language(lang).to_s.to_sym]
-    if messages.nil?
-      CustomMessageSetting.reload_translations!([lang])
-      messages = I18n.backend.send(:translations)[lang.to_s.to_sym] || {}
-    end
-    self.flatten_hash(messages)
-  end
-
   # { date: { formats: { defaults: '%m/%d/%Y'}}} to {'date.formats.defaults' => '%m/%d/%Y'}
   def self.flatten_hash(hash=nil)
-    hash = self.to_hash unless hash
+    return hash unless hash.is_a?(Hash)
+
     hash.each_with_object({}) do |(key, value), content|
       next self.flatten_hash(value).each do |k, v|
-        content["#{key}.#{k}".intern] = v
+        content[:"#{key}.#{k}"] = v
       end if value.is_a? Hash
       content[key] = value
     end
@@ -108,7 +86,6 @@ def self.nested_hash(hash=nil)
     new_hash = {}
     hash.each do |key, value|
       h = value
-      h = YAML.load(value) if value.first == '[' && value.last == ']'
       key.to_s.split('.').reverse_each do |k|
         h = {k => h}
       end
@@ -117,62 +94,60 @@ def self.nested_hash(hash=nil)
     new_hash
   end
 
-  def self.reload_translations!(languages)
-    paths = I18n.load_path.select {|path| self.find_language(languages).include?(File.basename(path, '.*').to_s)}
-    I18n.backend.load_translations(paths)
-  end
+  private
 
-  def self.find_language(language=nil)
-    if language.is_a?(Array)
-      language.select{|l| I18n.available_locales.include?(l.to_s.to_sym)}.map(&:to_s).compact
-    elsif language.present? && I18n.available_locales.include?(language.to_s.to_sym)
-      language.to_s
-    else
-      nil
-    end
+  def raw_custom_messages
+    self.value[:custom_messages] || self.value['custom_messages']
   end
 
-  private
+  def custom_messages=(messages)
+    messages = YAML.load("#{messages}") unless messages.is_a?(Hash)
+    self.value = self.value.merge({custom_messages: messages.presence || {}})
+  rescue Psych::SyntaxError => e
+    self.value = self.value.merge({custom_messages: messages})
+  end
 
   def custom_message_keys_are_available
-    return false if !value[:custom_messages].is_a?(Hash) || errors.present?
+    return if errors.present?
+
+    en_translation_hash = self.class.flatten_hash(MessageCustomize::Locale.available_messages('en'))
+    custom_message_keys =
+      custom_messages.values.each_with_object([]){|val, ar|
+        ar.concat(self.class.flatten_hash(val).keys)
+      }.uniq
+
+    unused_keys = custom_message_keys.reject{|k| en_translation_hash.keys.include?(:"#{k}")}
+    unusable_type_of_keys = (custom_message_keys - unused_keys).reject{|k| en_translation_hash[:"#{k}"].is_a?(String)}
 
-    custom_messages_hash = {}
-    custom_messages.values.compact.each do |val|
-      custom_messages_hash = self.class.flatten_hash(custom_messages_hash.merge(val)) if val.is_a?(Hash)
+    if unused_keys.present?
+      errors.add(:base, "#{l(:error_unused_keys)} keys: [#{unused_keys.join(', ')}]")
     end
-    available_keys = self.class.flatten_hash(self.class.available_messages('en')).keys
-    unavailable_keys = custom_messages_hash.keys.reject{|k| available_keys.include?(k.to_sym)}
-    if unavailable_keys.present?
-      self.errors.add(:base, l(:error_unavailable_keys) + " keys: [#{unavailable_keys.join(', ')}]")
-      false
+    if unusable_type_of_keys.present?
+      errors.add(:base, "#{l(:error_unusable_type_of_keys)} keys: [#{unusable_type_of_keys.join(', ')}]")
     end
   end
 
   def custom_message_languages_are_available
-    return false if !value[:custom_messages].is_a?(Hash) || errors.present?
+    return if errors.present?
 
     unavailable_languages =
       custom_messages.keys.compact.reject do |language|
-        I18n.available_locales.include?(language.to_sym)
+        MessageCustomize::Locale.available_locales.include?(language.to_sym)
       end
     if unavailable_languages.present?
-      self.errors.add(:base, l(:error_unavailable_languages) + " [#{unavailable_languages.join(', ')}]")
-      false
+      errors.add(:base, l(:error_unavailable_languages) + " [#{unavailable_languages.join(', ')}]")
     end
   end
 
   def convertible_to_yaml
-    YAML.dump(self.value[:custom_messages])
-  end
-
-  def add_errors
-    if @errs.present?
-      @errs.each do |key, value|
-        self.errors.add(key, value)
+    raw_messages = raw_custom_messages
+    if raw_messages.present? && !raw_messages.is_a?(Hash)
+      begin
+        YAML.load("#{raw_messages}")
+        errors.add(:base, l(:error_invalid_yaml_format))
+      rescue Psych::SyntaxError => e
+        errors.add(:base, "#{l(:error_invalid_yaml_format)} #{e.message}")
       end
-      @errs = nil
-      false
     end
   end
-end
+end