i18n-tasks 1.0.14 → 1.1.0

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
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/reports/base'
-require 'terminal-table'
+require "i18n/tasks/reports/base"
+require "terminal-table"
 module I18n
   module Tasks
     module Reports
@@ -10,17 +10,17 @@ module I18n
           forest = collapse_missing_tree! forest
           if forest.present?
             print_title missing_title(forest)
-            print_table headings: [Rainbow(I18n.t('i18n_tasks.common.locale')).cyan.bright,
-                                   Rainbow(I18n.t('i18n_tasks.common.key')).cyan.bright,
-                                   I18n.t('i18n_tasks.missing.details_title')] do |t|
+            print_table headings: [Rainbow(I18n.t("i18n_tasks.common.locale")).cyan.bright,
+              Rainbow(I18n.t("i18n_tasks.common.key")).cyan.bright,
+              I18n.t("i18n_tasks.missing.details_title")] do |t|
               t.rows = sort_by_attr!(forest_to_attr(forest)).map do |a|
-                [{ value: Rainbow(format_locale(a[:locale])).cyan, alignment: :center },
-                 format_key(a[:key], a[:data]),
-                 missing_key_info(a)]
+                [{value: Rainbow(format_locale(a[:locale])).cyan, alignment: :center},
+                  format_key(a[:key], a[:data]),
+                  missing_key_info(a)]
               end
             end
           else
-            print_success I18n.t('i18n_tasks.missing.none')
+            print_success I18n.t("i18n_tasks.missing.none")
           end
         end
 
@@ -29,7 +29,24 @@ module I18n
             print_title inconsistent_interpolations_title(forest)
             show_tree(forest)
           else
-            print_success I18n.t('i18n_tasks.inconsistent_interpolations.none')
+            print_success I18n.t("i18n_tasks.inconsistent_interpolations.none")
+          end
+        end
+
+        def reserved_interpolations(forest = task.reserved_interpolations)
+          if forest.present?
+            print_title reserved_interpolations_title(forest)
+            print_table headings: [Rainbow(I18n.t("i18n_tasks.common.locale")).cyan.bright,
+              Rainbow(I18n.t("i18n_tasks.common.key")).cyan.bright,
+              I18n.t("i18n_tasks.reserved_interpolations.details_title")] do |t|
+              t.rows = sort_by_attr!(forest_to_attr(forest)).map do |a|
+                [{value: Rainbow(format_locale(a[:locale])).cyan, alignment: :center},
+                  format_key(a[:key], a[:data]),
+                  a[:value].join(", ")]
+              end
+            end
+          else
+            print_success I18n.t("i18n_tasks.reserved_interpolations.none")
           end
         end
 
@@ -45,7 +62,7 @@ module I18n
               print_occurrences node, key
             end
           else
-            print_error I18n.t('i18n_tasks.usages.none')
+            print_error I18n.t("i18n_tasks.usages.none")
           end
         end
 
@@ -55,7 +72,7 @@ module I18n
             print_title unused_title(keys)
             print_locale_key_value_data_table keys
           else
-            print_success I18n.t('i18n_tasks.unused.none')
+            print_success I18n.t("i18n_tasks.unused.none")
           end
         end
 
@@ -65,7 +82,7 @@ module I18n
             print_title eq_base_title(keys)
             print_locale_key_value_data_table keys
           else
-            print_info Rainbow('No translations are the same as base value').cyan
+            print_info Rainbow("No translations are the same as base value").cyan
           end
         end
 
@@ -74,39 +91,39 @@ module I18n
         end
 
         def forest_stats(forest, stats = task.forest_stats(forest))
-          text  = if stats[:locale_count] == 1
-                    I18n.t('i18n_tasks.data_stats.text_single_locale', **stats)
-                  else
-                    I18n.t('i18n_tasks.data_stats.text', **stats)
-                  end
-          title = Rainbow(I18n.t('i18n_tasks.data_stats.title', **stats.slice(:locales))).bright
+          text = if stats[:locale_count] == 1
+            I18n.t("i18n_tasks.data_stats.text_single_locale", **stats)
+          else
+            I18n.t("i18n_tasks.data_stats.text", **stats)
+          end
+          title = Rainbow(I18n.t("i18n_tasks.data_stats.title", **stats.slice(:locales))).bright
           print_info "#{Rainbow(title).cyan} #{Rainbow(text).cyan}"
         end
 
         def mv_results(results)
           results.each do |(from, to)|
             if to
-              print_info "#{Rainbow(from).cyan} #{Rainbow('⮕').yellow.bright} #{Rainbow(to).cyan}"
+              print_info "#{Rainbow(from).cyan} #{Rainbow("⮕").yellow.bright} #{Rainbow(to).cyan}"
             else
-              print_info "#{Rainbow(from).red}#{Rainbow(' 🗑').red.bright}"
+              print_info "#{Rainbow(from).red}#{Rainbow(" 🗑").red.bright}"
             end
           end
         end
 
         def cp_results(results)
           results.each do |(from, to)|
-            print_info "#{Rainbow(from).cyan} #{Rainbow('+').yellow.bright} #{Rainbow(to).green}"
+            print_info "#{Rainbow(from).cyan} #{Rainbow("+").yellow.bright} #{Rainbow(to).green}"
           end
         end
 
         def check_normalized_results(non_normalized)
           if non_normalized.empty?
-            print_success 'All data is normalized'
+            print_success "All data is normalized"
             return
           end
-          log_stderr Rainbow('The following data requires normalization:').yellow
+          log_stderr Rainbow("The following data requires normalization:").yellow
           puts non_normalized
-          log_stderr Rainbow('Run `i18n-tasks normalize` to fix').yellow
+          log_stderr Rainbow("Run `i18n-tasks normalize` to fix").yellow
         end
 
         private
@@ -116,7 +133,7 @@ module I18n
           when :missing_used
             first_occurrence leaf
           when :missing_plural
-            leaf[:data][:missing_keys].join(', ')
+            leaf[:data][:missing_keys].join(", ")
           else
             "#{Rainbow(leaf[:data][:missing_diff_locale]).cyan} " \
             "#{format_value(leaf[:value].is_a?(String) ? leaf[:value].strip : leaf[:value])}"
@@ -127,16 +144,16 @@ module I18n
           if data[:ref_info]
             from, to = data[:ref_info]
             resolved = key[0...to.length]
-            after    = key[to.length..]
+            after = key[to.length..]
             "  #{Rainbow(from).yellow}#{Rainbow(after).cyan}\n" \
-              "#{Rainbow('⮕').yellow.bright} #{Rainbow(resolved).yellow.bright}"
+              "#{Rainbow("⮕").yellow.bright} #{Rainbow(resolved).yellow.bright}"
           else
             Rainbow(key).cyan
           end
         end
 
         def format_value(val)
-          val.is_a?(Symbol) ? "#{Rainbow('⮕ ').yellow.bright}#{Rainbow(val).yellow}" : val.to_s.strip
+          val.is_a?(Symbol) ? "#{Rainbow("⮕ ").yellow.bright}#{Rainbow(val).yellow}" : val.to_s.strip
         end
 
         def format_reference_desc(node_data)
@@ -144,19 +161,19 @@ module I18n
 
           case node_data[:ref_type]
           when :reference_usage
-            Rainbow('(ref)').yellow.bright
+            Rainbow("(ref)").yellow.bright
           when :reference_usage_resolved
-            Rainbow('(resolved ref)').yellow.bright
+            Rainbow("(resolved ref)").yellow.bright
           when :reference_usage_key
-            Rainbow('(ref key)').yellow.bright
+            Rainbow("(ref key)").yellow.bright
           end
         end
 
         def print_occurrences(node, full_key = node.full_key)
           occurrences = node.data[:occurrences]
           puts [Rainbow(full_key).bright,
-                format_reference_desc(node.data),
-                (Rainbow(occurrences.size).green if occurrences.size > 1)].compact.join ' '
+            format_reference_desc(node.data),
+            (Rainbow(occurrences.size).green if occurrences.size > 1)].compact.join " "
           occurrences.each do |occurrence|
             puts "  #{key_occurrence full_key, occurrence}"
           end
@@ -164,25 +181,25 @@ module I18n
 
         def print_locale_key_value_data_table(locale_key_value_datas)
           if locale_key_value_datas.present?
-            print_table headings: [Rainbow(I18n.t('i18n_tasks.common.locale')).cyan.bright,
-                                   Rainbow(I18n.t('i18n_tasks.common.key')).cyan.bright,
-                                   I18n.t('i18n_tasks.common.value')] do |t|
+            print_table headings: [Rainbow(I18n.t("i18n_tasks.common.locale")).cyan.bright,
+              Rainbow(I18n.t("i18n_tasks.common.key")).cyan.bright,
+              I18n.t("i18n_tasks.common.value")] do |t|
               t.rows = locale_key_value_datas.map do |(locale, k, v, data)|
-                [{ value: Rainbow(locale).cyan, alignment: :center }, format_key(k, data), format_value(v)]
+                [{value: Rainbow(locale).cyan, alignment: :center}, format_key(k, data), format_value(v)]
               end
             end
           else
-            puts 'ø'
+            puts "ø"
           end
         end
 
         def print_title(title)
-          log_stderr "#{Rainbow(title.strip).bright} #{Rainbow('|').faint} " \
+          log_stderr "#{Rainbow(title.strip).bright} #{Rainbow("|").faint} " \
                      "#{"i18n-tasks v#{I18n::Tasks::VERSION}"}"
         end
 
         def print_success(message)
-          log_stderr Rainbow("✓ #{I18n.t('i18n_tasks.cmd.encourage').sample} #{message}").green.bright
+          log_stderr Rainbow("✓ #{I18n.t("i18n_tasks.cmd.encourage").sample} #{message}").green.bright
         end
 
         def print_error(message)
@@ -194,16 +211,16 @@ module I18n
         end
 
         def indent(txt, n = 2)
-          txt.gsub(/^/, ' ' * n)
+          txt.gsub(/^/, " " * n)
         end
 
-        def print_table(opts, &block)
-          puts ::Terminal::Table.new(opts, &block)
+        def print_table(opts, &)
+          puts ::Terminal::Table.new(opts, &)
         end
 
         def key_occurrence(full_key, occurrence)
           location = Rainbow("#{occurrence.path}:#{occurrence.line_num}").green
-          source   = highlight_key(occurrence.raw_key || full_key, occurrence.line, occurrence.line_pos..-1).strip
+          source = highlight_key(occurrence.raw_key || full_key, occurrence.line, occurrence.line_pos..-1).strip
           "#{location} #{source}"
         end
 
@@ -214,8 +231,8 @@ module I18n
           first = occurrences.first
           [
             Rainbow("#{first.path}:#{first.line_num}").green,
-            ("(#{I18n.t 'i18n_tasks.common.n_more', count: occurrences.length - 1})" if occurrences.length > 1)
-          ].compact.join(' ')
+            ("(#{I18n.t "i18n_tasks.common.n_more", count: occurrences.length - 1})" if occurrences.length > 1)
+          ].compact.join(" ")
         end
 
         def highlight_key(full_key, line, range = (0..-1))

data/lib/i18n/tasks/scanners/ast_matchers/base_matcher.rb

@@ -7,7 +7,7 @@ module I18n::Tasks::Scanners::AstMatchers
     end
 
     def convert_to_key_occurrences(send_node, _method_name, location: send_node.loc)
-      fail('Not implemented')
+      fail("Not implemented")
     end
 
     protected
@@ -32,7 +32,7 @@ module I18n::Tasks::Scanners::AstMatchers
       elsif %i[true false].include?(node.type)
         node.type.to_s
       elsif node.type == :nil
-        ''
+        ""
       elsif node.type == :array && array_join_with
         extract_array_as_string(
           node,
@@ -109,7 +109,7 @@ module I18n::Tasks::Scanners::AstMatchers
       if array_reject_blank
         children_strings.reject! do |x|
           # empty strings and nils in the scope argument are ignored by i18n
-          x == ''
+          x == ""
         end
       end
       children_strings.join(array_join_with)

data/lib/i18n/tasks/scanners/ast_matchers/default_i18n_subject_matcher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/scanners/ast_matchers/base_matcher'
-require 'i18n/tasks/scanners/results/occurrence'
+require "i18n/tasks/scanners/ast_matchers/base_matcher"
+require "i18n/tasks/scanners/results/occurrence"
 
 module I18n::Tasks::Scanners::AstMatchers
   class DefaultI18nSubjectMatcher < BaseMatcher
@@ -10,7 +10,7 @@ module I18n::Tasks::Scanners::AstMatchers
       return unless children[1] == :default_i18n_subject
 
       key = @scanner.absolute_key(
-        '.subject',
+        ".subject",
         location.expression.source_buffer.name,
         calling_method: method_name
       )

data/lib/i18n/tasks/scanners/ast_matchers/message_receivers_matcher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/scanners/ast_matchers/base_matcher'
-require 'i18n/tasks/scanners/results/occurrence'
+require "i18n/tasks/scanners/ast_matchers/base_matcher"
+require "i18n/tasks/scanners/results/occurrence"
 
 module I18n::Tasks::Scanners::AstMatchers
   class MessageReceiversMatcher < BaseMatcher
@@ -64,25 +64,25 @@ module I18n::Tasks::Scanners::AstMatchers
     def process_options(node:, key:)
       return [key, nil] if node&.type != :hash
 
-      scope_node = extract_hash_pair(node, 'scope')
+      scope_node = extract_hash_pair(node, "scope")
 
       if scope_node
         scope = extract_string(
           scope_node.children[1],
-          array_join_with: '.',
+          array_join_with: ".",
           array_flatten: true,
           array_reject_blank: true
         )
         return nil if scope.nil? && scope_node.type != :nil
 
-        key = [scope, key].join('.') unless scope == ''
+        key = [scope, key].join(".") unless scope == ""
       end
-      if default_arg_node = extract_hash_pair(node, 'default')
+      if (default_arg_node = extract_hash_pair(node, "default"))
         default_arg = if default_arg_node.children[1]&.type == :hash
-                        extract_hash(default_arg_node.children[1])
-                      else
-                        extract_string(default_arg_node.children[1])
-                      end
+          extract_hash(default_arg_node.children[1])
+        else
+          extract_string(default_arg_node.children[1])
+        end
       end
 
       [key, default_arg]

data/lib/i18n/tasks/scanners/ast_matchers/rails_model_matcher.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/scanners/results/occurrence'
+require "i18n/tasks/scanners/results/occurrence"
 
 module I18n::Tasks::Scanners::AstMatchers
   class RailsModelMatcher < BaseMatcher
@@ -16,7 +16,7 @@ module I18n::Tasks::Scanners::AstMatchers
       receiver = children[0]
       method_name = children[1]
 
-      return unless method_name == :human_attribute_name && receiver.type == :const
+      return unless method_name == :human_attribute_name && receiver&.type == :const
 
       value = children[2]