i18n-tasks 1.0.15 → 1.1.0

data/lib/i18n/tasks/data/tree/nodes.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/data/tree/traversal'
+require "i18n/tasks/data/tree/traversal"
 module I18n::Tasks::Data::Tree
   # A list of nodes
   class Nodes
@@ -20,7 +20,7 @@ module I18n::Tasks::Data::Tree
     end
 
     def attributes
-      { nodes: @list }
+      {nodes: @list}
     end
 
     def derive(new_attr = {})
@@ -32,10 +32,10 @@ module I18n::Tasks::Data::Tree
 
     def to_hash(sort = false)
       (@hash ||= {})[sort] ||= if sort
-                                 sort_by(&:key)
-                               else
-                                 self
-                               end.map { |node| node.to_hash(sort) }.reduce({}, :deep_merge!)
+        sort_by(&:key)
+      else
+        self
+      end.map { |node| node.to_hash(sort) }.reduce({}, :deep_merge!)
     end
 
     delegate :to_json, to: :to_hash
@@ -45,7 +45,7 @@ module I18n::Tasks::Data::Tree
       if present?
         map(&:inspect) * "\n"
       else
-        Rainbow('{∅}').faint
+        Rainbow("{∅}").faint
       end
     end
 
@@ -67,14 +67,14 @@ module I18n::Tasks::Data::Tree
       derive.append!(other)
     end
 
-    alias << append
+    alias_method :<<, :append
 
     def merge!(nodes)
       @list += nodes.to_a
       dirty!
       self
     end
-    alias + merge!
+    alias_method :+, :merge!
 
     def children(&block)
       return to_enum(:children) { map { |c| c.children ? c.children.size : 0 }.reduce(:+) } unless block
@@ -84,7 +84,7 @@ module I18n::Tasks::Data::Tree
       end
     end
 
-    alias children? any?
+    alias_method :children?, :any?
 
     protected
 

data/lib/i18n/tasks/data/tree/siblings.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'i18n/tasks/split_key'
-require 'i18n/tasks/data/tree/nodes'
+require "set"
+require "i18n/tasks/split_key"
+require "i18n/tasks/data/tree/nodes"
 
 module I18n::Tasks::Data::Tree
   # Siblings represents a subtree sharing a common parent
@@ -17,7 +17,7 @@ module I18n::Tasks::Data::Tree
     def initialize(opts = {})
       super(nodes: opts[:nodes])
       @parent = opts[:parent] || first.try(:parent)
-      @list.map! { |node| node.parent == @parent ? node : node.derive(parent: @parent) }
+      @list.map! { |node| (node.parent == @parent) ? node : node.derive(parent: @parent) }
       @key_to_node = @list.each_with_object({}) { |node, h| h[node.key] = node }
       @warn_about_add_children_to_leaf = opts.fetch(:warn_about_add_children_to_leaf, true)
     end
@@ -52,7 +52,7 @@ module I18n::Tasks::Data::Tree
           new_key = to_pattern.gsub(/\\\d+/) { |m| match[m[1..].to_i] }
           old_key_to_new_key[full_key] = new_key
           moved_forest.merge!(Siblings.new.tap do |forest|
-            forest[[(node.root.try(:key) unless root), new_key].compact.join('.')] =
+            forest[[(node.root.try(:key) unless root), new_key].compact.join(".")] =
               node.derive(key: split_key(new_key).last)
           end)
         end
@@ -62,10 +62,10 @@ module I18n::Tasks::Data::Tree
       nodes do |node|
         next unless node.reference?
 
-        old_target = [(node.root.key if root), node.value.to_s].compact.join('.')
+        old_target = [(node.root.key if root), node.value.to_s].compact.join(".")
         new_target = old_key_to_new_key[old_target]
         if new_target
-          new_target = new_target.sub(/\A[^.]*\./, '') if root
+          new_target = new_target.sub(/\A[^.]*\./, "") if root
           node.value = new_target.to_sym
         end
       end
@@ -75,26 +75,26 @@ module I18n::Tasks::Data::Tree
     end
 
     def replace_node!(node, new_node)
-      @list[@list.index(node)]  = new_node
+      @list[@list.index(node)] = new_node
       key_to_node[new_node.key] = new_node
     end
 
     # @return [Node] by full key
     def get(full_key)
       first_key, rest = split_key(full_key.to_s, 2)
-      node            = key_to_node[first_key]
+      node = key_to_node[first_key]
       node = node.children.try(:get, rest) if rest && node
       node
     end
 
-    alias [] get
+    alias_method :[], :get
 
     # add or replace node by full key
     def set(full_key, node)
-      fail 'value should be a I18n::Tasks::Data::Tree::Node' unless node.is_a?(Node)
+      fail "value should be a I18n::Tasks::Data::Tree::Node" unless node.is_a?(Node)
 
       key_part, rest = split_key(full_key, 2)
-      child          = key_to_node[key_part]
+      child = key_to_node[key_part]
 
       if rest
         unless child
@@ -119,7 +119,7 @@ module I18n::Tasks::Data::Tree
       node
     end
 
-    alias []= set
+    alias_method :[]=, :set
 
     # methods below change state
 
@@ -133,9 +133,9 @@ module I18n::Tasks::Data::Tree
       nodes = nodes.map do |node|
         fail "already has a child with key '#{node.key}'" if key_to_node.key?(node.key)
 
-        key_to_node[node.key] = (node.parent == parent ? node : node.derive(parent: parent))
+        key_to_node[node.key] = ((node.parent == parent) ? node : node.derive(parent: parent))
       end
-      super(nodes)
+      super
       self
     end
 
@@ -267,7 +267,7 @@ module I18n::Tasks::Data::Tree
           key_occurrences.each do |key_occurrence|
             forest[key_occurrence.key] = ::I18n::Tasks::Data::Tree::Node.new(
               key: split_key(key_occurrence.key).last,
-              data: { occurrences: key_occurrence.occurrences }
+              data: {occurrences: key_occurrence.occurrences}
             )
           end
         end
@@ -276,9 +276,9 @@ module I18n::Tasks::Data::Tree
       def from_key_attr(key_attrs, opts = {}, &block)
         build_forest(opts) do |forest|
           key_attrs.each do |(full_key, attr)|
-            fail "Invalid key #{full_key.inspect}" if full_key.end_with?('.')
+            fail "Invalid key #{full_key.inspect}" if full_key.end_with?(".")
 
-            node = ::I18n::Tasks::Data::Tree::Node.new(**attr.merge(key: split_key(full_key).last))
+            node = ::I18n::Tasks::Data::Tree::Node.new(**attr, key: split_key(full_key).last)
             yield(full_key, node) if block
             forest[full_key] = node
           end
@@ -305,7 +305,7 @@ module I18n::Tasks::Data::Tree
         Siblings.new(opts)
       end
 
-      alias [] from_nested_hash
+      alias_method :[], :from_nested_hash
 
       # build forest from [[Full Key, Value]]
       def from_flat_pairs(pairs)
@@ -323,7 +323,7 @@ module I18n::Tasks::Data::Tree
         opts[:parent] = ::I18n::Tasks::Data::Tree::Node.new(opts[:parent_attr]) if opts[:parent_attr]
         if opts[:parent_locale]
           opts[:parent] = ::I18n::Tasks::Data::Tree::Node.new(
-            key: opts[:parent_locale], data: { locale: opts[:parent_locale] }
+            key: opts[:parent_locale], data: {locale: opts[:parent_locale]}
           )
         end
       end

data/lib/i18n/tasks/data/tree/traversal.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
 module I18n::Tasks
   module Data::Tree
     # Any Enumerable that yields nodes can mix in this module
     module Traversal # rubocop:disable Metrics/ModuleLength
-      def nodes(&block)
-        depth_first(&block)
+      def nodes(&)
+        depth_first(&)
       end
 
       def leaves(&visitor)
@@ -76,13 +76,13 @@ module I18n::Tasks
 
       def root_key_values(sort = false)
         result = keys(root: false).map { |key, node| [node.root.key, key, node.value] }
-        result.sort! { |a, b| a[0] == b[0] ? a[1] <=> b[1] : a[0] <=> b[0] } if sort
+        result.sort! { |a, b| (a[0] == b[0]) ? a[1] <=> b[1] : a[0] <=> b[0] } if sort
         result
       end
 
       def root_key_value_data(sort = false)
         result = keys(root: false).map { |key, node| [node.root.key, key, node.value, node.data] }
-        result.sort! { |a, b| a[0] == b[0] ? a[1] <=> b[1] : a[0] <=> b[0] } if sort
+        result.sort! { |a, b| (a[0] == b[0]) ? a[1] <=> b[1] : a[0] <=> b[0] } if sort
         result
       end
 

data/lib/i18n/tasks/data.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/data/file_system'
+require "i18n/tasks/data/file_system"
 
 module I18n::Tasks
   module Data
     DATA_DEFAULTS = {
-      adapter: 'I18n::Tasks::Data::FileSystem'
+      adapter: "I18n::Tasks::Data::FileSystem"
     }.freeze
 
     # I18n data provider
@@ -17,7 +17,7 @@ module I18n::Tasks
         data_config[:locales] = config[:locales]
         adapter_class = data_config[:adapter].presence || data_config[:class].presence || DATA_DEFAULTS[:adapter]
         adapter_class = adapter_class.to_s
-        adapter_class = 'I18n::Tasks::Data::FileSystem' if adapter_class == 'file_system'
+        adapter_class = "I18n::Tasks::Data::FileSystem" if adapter_class == "file_system"
         data_config.except!(:adapter, :class)
         ActiveSupport::Inflector.constantize(adapter_class).new data_config
       end
@@ -50,7 +50,7 @@ module I18n::Tasks
     end
 
     def t_proc(locale = base_locale)
-      @t_proc         ||= {}
+      @t_proc ||= {}
       @t_proc[locale] ||= proc { |key| t(key, locale) }
     end
 

data/lib/i18n/tasks/html_keys.rb

@@ -2,8 +2,8 @@
 
 module I18n::Tasks
   module HtmlKeys
-    HTML_KEY_PATTERN = /[.\-_]html\z/.freeze
-    MAYBE_PLURAL_HTML_KEY_PATTERN = /[.\-_]html\.[^.]+\z/.freeze
+    HTML_KEY_PATTERN = /[.\-_]html\z/
+    MAYBE_PLURAL_HTML_KEY_PATTERN = /[.\-_]html\.[^.]+\z/
 
     def html_key?(full_key, locale)
       !!(full_key =~ HTML_KEY_PATTERN ||

data/lib/i18n/tasks/ignore_keys.rb

@@ -12,19 +12,19 @@ module I18n::Tasks::IgnoreKeys
   # @param locale [String] only when type is :eq_base
   # @return [Regexp] a regexp that matches all the keys ignored for the type (and locale)
   def ignore_pattern(type, locale = nil)
-    @ignore_patterns              ||= HashWithIndifferentAccess.new
-    @ignore_patterns[type]        ||= {}
+    @ignore_patterns ||= HashWithIndifferentAccess.new
+    @ignore_patterns[type] ||= {}
     @ignore_patterns[type][locale] ||= begin
       global = ignore_config.presence || []
       type_ignore = ignore_config(type).presence || []
       patterns = case type_ignore
-                 when Array
-                   global + type_ignore
-                 when Hash
-                   # ignore per locale
-                   global + (type_ignore['all'] || []) +
-                   type_ignore.select { |k, _v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
-                 end
+      when Array
+        global + type_ignore
+      when Hash
+        # ignore per locale
+        global + (type_ignore["all"] || []) +
+          type_ignore.select { |k, _v| k.to_s =~ /\b#{locale}\b/ }.values.flatten(1).compact
+      end
       compile_patterns_re patterns
     end
   end

data/lib/i18n/tasks/interpolations.rb

@@ -5,7 +5,7 @@ module I18n::Tasks
     class << self
       attr_accessor :variable_regex
     end
-    @variable_regex = /(?<!%)%{[^}]+}/.freeze
+    @variable_regex = /(?<!%)%{[^}]+}/
 
     def inconsistent_interpolations(locales: nil, base_locale: nil) # rubocop:disable Metrics/AbcSize
       locales ||= self.locales
@@ -30,5 +30,25 @@ module I18n::Tasks
       result.each { |root| root.data[:type] = :inconsistent_interpolations }
       result
     end
+
+    def reserved_interpolations(locales: nil)
+      locales ||= self.locales
+      result = empty_forest
+
+      locales.each do |current_locale|
+        data[current_locale].key_values.each do |key, value|
+          next unless value.is_a?(String)
+
+          reserved_variables = value.scan(::I18n.reserved_keys_pattern).flatten
+          next if reserved_variables.empty?
+
+          result.merge!(data[current_locale].first.children[key].walk_to_root.reduce(nil) do |c, p|
+            [p.derive(children: c, value: reserved_variables)]
+          end)
+        end
+      end
+      result.each { |root| root.data[:type] = :inconsistent_interpolations }
+      result
+    end
   end
 end

data/lib/i18n/tasks/key_pattern_matching.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'strscan'
+require "strscan"
 
 module I18n::Tasks::KeyPatternMatching
   extend self # rubocop:disable Style/ModuleFunction
 
-  MATCH_NOTHING = /\z\A/.freeze
+  MATCH_NOTHING = /\z\A/
 
   # one regex to match any
   def compile_patterns_re(key_patterns)
@@ -13,7 +13,7 @@ module I18n::Tasks::KeyPatternMatching
       # match nothing
       MATCH_NOTHING
     else
-      /(?:#{key_patterns.map { |p| compile_key_pattern p } * '|'})/m
+      /(?:#{key_patterns.map { |p| compile_key_pattern p } * "|"})/m
     end
   end
 
@@ -31,10 +31,10 @@ module I18n::Tasks::KeyPatternMatching
 
   def key_pattern_re_body(key_pattern)
     key_pattern
-      .gsub('.', '\.')
-      .gsub('*:', '[^.]+?')
-      .gsub('*', '.*')
-      .gsub(':', '(?<=^|\.)[^.]+?(?=\.|$)')
-      .gsub(/\{(.*?)}/) { "(#{Regexp.last_match(1).strip.gsub(/\s*,\s*/, '|')})" }
+      .gsub(".", '\.')
+      .gsub("*:", "[^.]+?")
+      .gsub("*", ".*")
+      .gsub(":", '(?<=^|\.)[^.]+?(?=\.|$)')
+      .gsub(/\{(.*?)}/) { "(#{Regexp.last_match(1).strip.gsub(/\s*,\s*/, "|")})" }
   end
 end

data/lib/i18n/tasks/logging.rb

@@ -25,7 +25,8 @@ module I18n::Tasks::Logging
   def log_stderr(*args)
     # We don't want output from different threads to get intermixed.
     MUTEX.synchronize do
-      $stderr.puts(*args)
+      # Use $stderr directly to avoid issues with JRuby and thread safety
+      $stderr.puts(*args) # rubocop:disable Style/StderrPuts
     end
   end
 

data/lib/i18n/tasks/missing_keys.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 module I18n::Tasks
   module MissingKeys # rubocop:disable Metrics/ModuleLength
     MISSING_TYPES = %w[
@@ -21,7 +21,7 @@ module I18n::Tasks
     # @return [Siblings]
     def missing_keys(locales: nil, types: nil, base_locale: nil)
       locales ||= self.locales
-      types   ||= missing_keys_types
+      types ||= missing_keys_types
       base = base_locale || self.base_locale
       types.inject(empty_forest) do |f, type|
         f.merge! send(:"missing_#{type}_forest", locales, base)
@@ -88,7 +88,7 @@ module I18n::Tasks
 
     # Loads rails-i18n pluralization config for the given locale.
     def load_rails_i18n_pluralization!(locale)
-      path = File.join(Gem::Specification.find_by_name('rails-i18n').gem_dir, 'rails', 'pluralization', "#{locale}.rb")
+      path = File.join(Gem::Specification.find_by_name("rails-i18n").gem_dir, "rails", "pluralization", "#{locale}.rb")
       eval(File.read(path), binding, path) # rubocop:disable Security/Eval
     end
 
@@ -98,7 +98,7 @@ module I18n::Tasks
         locale_key_missing? locale, depluralize_key(key, compared_to)
       end.set_root_key!(locale, type: :missing_diff).keys do |_key, node|
         # change path and locale to base
-        data = { locale: locale, missing_diff_locale: node.data[:locale] }
+        data = {locale: locale, missing_diff_locale: node.data[:locale]}
         if node.data.key?(:path)
           data[:path] = LocalePathname.replace_locale(node.data[:path], node.data[:locale], locale)
         end
@@ -108,8 +108,24 @@ module I18n::Tasks
 
     # keys used in the code missing translations in locale
     def missing_used_tree(locale)
-      used_tree(strict: true).select_keys do |key, _node|
-        locale_key_missing?(locale, key)
+      used_tree(strict: true).select_keys do |key, node|
+        occurrences = node.data[:occurrences] || []
+
+        # An occurrence may carry candidate keys (for relative lookups). If any
+        # candidate key exists in the locale, the usage is considered present.
+        occurrences_all_missing = occurrences.all? do |occ|
+          candidates = if occ.respond_to?(:candidate_keys) && occ.candidate_keys.present?
+            occ.candidate_keys
+          else
+            # fallback to the scanned key
+            [key]
+          end
+
+          # Occurrence is missing iff all its candidates are missing
+          candidates.all? { |c| locale_key_missing?(locale, c) }
+        end
+
+        occurrences_all_missing
       end.set_root_key!(locale, type: :missing_used)
     end
 
@@ -130,7 +146,7 @@ module I18n::Tasks
     # @yieldreturn [Boolean] whether to collapse the node
     def collapse_same_key_in_locales!(forest)
       locales_and_node_by_key = {}
-      to_remove               = []
+      to_remove = []
       forest.each do |root|
         locale = root.key
         root.keys do |key, node|
@@ -146,7 +162,7 @@ module I18n::Tasks
       end
       forest.remove_nodes_and_emptied_ancestors! to_remove
       locales_and_node_by_key.each_with_object({}) do |(key, (locales, node)), inv|
-        (inv[locales.sort.join('+')] ||= []) << [key, node]
+        (inv[locales.sort.join("+")] ||= []) << [key, node]
       end.map do |locales, keys_nodes|
         keys_nodes.each do |(key, node)|
           forest["#{locales}.#{key}"] = node

data/lib/i18n/tasks/plural_keys.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 module I18n::Tasks::PluralKeys
   # Ref: http://cldr.unicode.org/index/cldr-spec/plural-rules
   CLDR_CATEGORY_KEYS = %w[zero one two few many other].freeze
   PLURAL_KEY_SUFFIXES = Set.new CLDR_CATEGORY_KEYS
-  PLURAL_KEY_RE = /\.(?:#{CLDR_CATEGORY_KEYS * '|'})$/.freeze
+  PLURAL_KEY_RE = /\.(?:#{CLDR_CATEGORY_KEYS * "|"})$/
+  # Ref: https://unicode-org.github.io/cldr/ldml/tr35-numbers.html#Explicit_0_1_rules
+  EXPLICIT_0_1 = %w[0 1].freeze
 
   def collapse_plural_nodes!(tree)
     tree.leaves.map(&:parent).compact.uniq.each do |node|
       children = node.children
       next unless plural_forms?(children)
 
-      node.value    = children.to_hash
+      node.value = children.to_hash
       node.children = nil
       node.data.merge! children.first.data
     end
@@ -56,6 +58,6 @@ module I18n::Tasks::PluralKeys
   end
 
   def plural_suffix?(key)
-    PLURAL_KEY_SUFFIXES.include?(key)
+    PLURAL_KEY_SUFFIXES.include?(key) || EXPLICIT_0_1.include?(key)
   end
 end

data/lib/i18n/tasks/references.rb

@@ -7,9 +7,9 @@ module I18n::Tasks
     # 2. Resolved references -- all the used references in their fully resolved form.
     # 3. Reference keys -- all the used reference keys.
     def process_references(usages,
-                           data_refs = merge_reference_trees(data_forest.select_keys { |_, node| node.reference? }))
-      fail ArgumentError, 'usages must be a Data::Tree::Instance' unless usages.is_a?(Data::Tree::Siblings)
-      fail ArgumentError, 'all_references must be a Data::Tree::Instance' unless data_refs.is_a?(Data::Tree::Siblings)
+      data_refs = merge_reference_trees(data_forest.select_keys { |_, node| node.reference? }))
+      fail ArgumentError, "usages must be a Data::Tree::Instance" unless usages.is_a?(Data::Tree::Siblings)
+      fail ArgumentError, "all_references must be a Data::Tree::Instance" unless data_refs.is_a?(Data::Tree::Siblings)
 
       raw_refs = empty_forest
       resolved_refs = empty_forest
@@ -90,7 +90,7 @@ module I18n::Tasks
           on_leaves_merge: lambda do |node, other|
             if node.value != other.value
               log_warn(
-                'Conflicting references: ' \
+                "Conflicting references: " \
                 "#{node.full_key(root: false)} ⮕ #{node.value} in #{node.data[:locale]}, " \
                 "but ⮕ #{other.value} in #{other.data[:locale]}"
               )

data/lib/i18n/tasks/reports/base.rb

@@ -15,55 +15,59 @@ module I18n::Tasks::Reports
     protected
 
     def missing_type_info(type)
-      ::I18n::Tasks::MissingKeys::MISSING_TYPES[type.to_s.sub(/\Amissing_/, '').to_sym]
+      ::I18n::Tasks::MissingKeys::MISSING_TYPES[type.to_s.sub(/\Amissing_/, "").to_sym]
     end
 
     def missing_title(forest)
-      "Missing translations (#{forest.leaves.count || '∅'})"
+      "Missing translations (#{forest.leaves.count || "∅"})"
     end
 
     def inconsistent_interpolations_title(forest)
-      "Inconsistent interpolations (#{forest.leaves.count || '∅'})"
+      "Inconsistent interpolations (#{forest.leaves.count || "∅"})"
+    end
+
+    def reserved_interpolations_title(forest)
+      "Reserved interpolations (#{forest.leaves.count || "∅"})"
     end
 
     def unused_title(key_values)
-      "Unused keys (#{key_values.count || '∅'})"
+      "Unused keys (#{key_values.count || "∅"})"
     end
 
     def eq_base_title(key_values, locale = base_locale)
-      "Same value as #{locale} (#{key_values.count || '∅'})"
+      "Same value as #{locale} (#{key_values.count || "∅"})"
     end
 
     def used_title(keys_nodes, filter)
       used_n = keys_nodes.map { |_k, node| node.data[:occurrences].size }.reduce(:+).to_i
-      "#{keys_nodes.size} key#{'s' if keys_nodes.size != 1}#{" matching '#{filter}'" if filter}" \
-        "#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n.positive?}"
+      "#{keys_nodes.size} key#{"s" if keys_nodes.size != 1}#{" matching '#{filter}'" if filter}" \
+        "#{" (#{used_n} usage#{"s" if used_n != 1})" if used_n.positive?}"
     end
 
     # Sort keys by their attributes in order
     # @param [Hash] order e.g. {locale: :asc, type: :desc, key: :asc}
-    def sort_by_attr!(objects, order = { locale: :asc, key: :asc })
+    def sort_by_attr!(objects, order = {locale: :asc, key: :asc})
       order_keys = order.keys
       objects.sort! do |a, b|
         by = order_keys.detect { |k| a[k] != b[k] }
-        order[by] == :desc ? b[by] <=> a[by] : a[by] <=> b[by]
+        (order[by] == :desc) ? b[by] <=> a[by] : a[by] <=> b[by]
       end
       objects
     end
 
     def forest_to_attr(forest)
       forest.keys(root: false).map do |key, node|
-        { key: key, value: node.value, type: node.data[:type], locale: node.root.key, data: node.data }
+        {key: key, value: node.value, type: node.data[:type], locale: node.root.key, data: node.data}
       end
     end
 
     def format_locale(locale)
-      return '' unless locale
+      return "" unless locale
 
-      if locale.split('+') == task.locales.sort
-        'all'
+      if locale.split("+") == task.locales.sort
+        "all"
       else
-        locale.tr '+', ' '
+        locale.tr "+", " "
       end
     end