i18n-tasks 1.1.2 → 1.2.0

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

@@ -90,15 +90,14 @@ module I18n::Tasks
 
       # Select the nodes for which the block returns true. Pre-order traversal.
       # @return [Siblings] a new tree
-      def select_nodes(&block)
-        tree = Siblings.new
+      def select_nodes(parent: nil, &block)
+        tree = Siblings.new(parent: parent)
         each do |node|
           next unless block.yield(node)
 
-          tree.append! node.derive(
-            parent: tree.parent,
-            children: (node.children.select_nodes(&block).to_a if node.children)
-          )
+          copy = node.derive(parent: parent, children: nil)
+          copy.children = node.children.select_nodes(parent: copy, &block) if node.children
+          tree.append! copy
         end
         tree
       end
@@ -167,34 +166,41 @@ module I18n::Tasks
       end
 
       def set_each_value!(val_pattern, key_pattern = nil, &value_proc) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # A lone placeholder keeps the value's type, so that an array stays an array
+        lone_placeholder = val_pattern&.match(/\A%\{(\w+)\}\z/)&.[](1)&.to_sym
+        interpolate = lambda do |values|
+          lone_value = values[lone_placeholder] if lone_placeholder
+          return lone_value.dup unless lone_value.nil?
+
+          StringInterpolation.interpolate_soft(val_pattern, values)
+        end
         value_proc ||= proc do |node|
           node_value = node.value
           next node_value if node.reference?
 
+          kept_value = node_value.is_a?(String) ? node_value.presence : node_value
           human_key = ActiveSupport::Inflector.humanize(node.key.to_s)
           full_key = node.full_key
           default = (node.data[:occurrences] || []).detect { |o| o.default_arg.presence }.try(:default_arg)
           if default.is_a?(Hash)
             default.each_with_object({}) do |(k, v), h|
-              h[k] = StringInterpolation.interpolate_soft(
-                val_pattern,
+              h[k] = interpolate.call(
                 value: node_value,
                 human_key: human_key,
                 key: full_key,
                 default: v,
-                value_or_human_key: node_value.presence || human_key,
-                value_or_default_or_human_key: node_value.presence || v || human_key
+                value_or_human_key: kept_value.nil? ? human_key : kept_value,
+                value_or_default_or_human_key: kept_value.nil? ? v || human_key : kept_value
               )
             end
           else
-            StringInterpolation.interpolate_soft(
-              val_pattern,
+            interpolate.call(
               value: node_value,
               human_key: human_key,
               key: full_key,
               default: default,
-              value_or_human_key: node_value.presence || human_key,
-              value_or_default_or_human_key: node_value.presence || default || human_key
+              value_or_human_key: kept_value.nil? ? human_key : kept_value,
+              value_or_default_or_human_key: kept_value.nil? ? default || human_key : kept_value
             )
           end
         end

data/lib/i18n/tasks/interpolations.rb

@@ -11,17 +11,34 @@ module I18n::Tasks
       locales ||= self.locales
       base_locale ||= self.base_locale
       result = empty_forest
-      variable_regex = I18n::Tasks::Interpolations.variable_regex
+      plural_keys = Set.new
+      plural_nodes(data[base_locale]) do |base_node|
+        next unless base_node.parent?
+
+        group_key = base_node.full_key(root: false)
+        base_node.children.each { |form| plural_keys << "#{group_key}.#{form.key}" }
+        next if ignore_key?(group_key, :inconsistent_interpolations)
+
+        (locales - [base_locale]).each do |current_locale|
+          node = data[current_locale].first.children[group_key]
+          inconsistent_plural_forms(current_locale, base_node, node).each do |form|
+            next if ignore_key?("#{group_key}.#{form.key}", :inconsistent_interpolations)
+
+            result.merge!(form.walk_to_root.reduce(nil) { |c, p| [p.derive(children: c)] })
+          end
+        end
+      end
 
       data[base_locale].key_values.each do |key, value|
+        next if plural_keys.include?(key)
         next if !value.is_a?(String) || ignore_key?(key, :inconsistent_interpolations)
 
-        base_vars = Set.new(value.scan(variable_regex))
+        base_vars = interpolation_variables(value)
         (locales - [base_locale]).each do |current_locale|
           node = data[current_locale].first.children[key]
           next unless node&.value.is_a?(String)
 
-          if base_vars != Set.new(node.value.scan(variable_regex))
+          if base_vars != interpolation_variables(node.value)
             result.merge!(node.walk_to_root.reduce(nil) { |c, p| [p.derive(children: c)] })
           end
         end
@@ -31,6 +48,47 @@ module I18n::Tasks
       result
     end
 
+    COUNT_VARIABLE = "%{count}"
+    # The forms that are used for at most one count when the locale has no plural rule in rails-i18n.
+    SINGLE_COUNT_PLURAL_FORMS = %w[zero one two 0 1].freeze
+
+    # Plural forms are compared as a group, because a locale has different forms than the base locale, and its forms
+    # cover different counts: the Russian `one` is used for 1, 21, 31, ..., so it needs `%{count}` even when the
+    # English `one` spells the number out. A form may only use the variables of the base forms, and must keep the
+    # variables of the same base form (or of `other` if the base locale does not have it). It may drop `%{count}`
+    # if it is used for at most one count, and must have it if it is used for several. The counts each form is used
+    # for come from the locale's rule in rails-i18n.
+    #
+    # Keys that are not plural forms in the translated group have no base form to compare with, and are skipped.
+    #
+    # @return [Array<I18n::Tasks::Data::Tree::Node>] the inconsistent forms of `node`
+    def inconsistent_plural_forms(locale, base_node, node)
+      return [] unless node&.children?
+
+      base_forms = base_node.children.to_h { |form| [form.key, interpolation_variables(form.value)] }
+      base_vars = base_forms.values.reduce(Set.new, :|)
+      forms = node.children.select { |form| form.leaf? && plural_suffix?(form.key) && form.value.is_a?(String) }
+      form_counts = plural_form_counts(locale, node.children.map(&:key))
+      forms.select do |form|
+        vars = interpolation_variables(form.value)
+        required = (base_forms[form.key] || base_forms["other"] || base_vars) - [COUNT_VARIABLE]
+        if several_plural_counts?(form_counts, form.key) && base_vars.include?(COUNT_VARIABLE)
+          required << COUNT_VARIABLE
+        end
+        !vars.subset?(base_vars) || !required.subset?(vars)
+      end
+    end
+
+    def several_plural_counts?(form_counts, form_key)
+      return !SINGLE_COUNT_PLURAL_FORMS.include?(form_key) if form_counts.nil?
+
+      form_counts.fetch(form_key, 0) > 1
+    end
+
+    def interpolation_variables(value)
+      value.is_a?(String) ? Set.new(value.scan(I18n::Tasks::Interpolations.variable_regex)) : Set.new
+    end
+
     def reserved_interpolations(locales: nil)
       locales ||= self.locales
       result = empty_forest

data/lib/i18n/tasks/logging.rb

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

data/lib/i18n/tasks/missing_keys.rb

@@ -51,8 +51,9 @@ module I18n::Tasks
     end
 
     def missing_used_forest(locales, _base = base_locale)
+      used = used_tree(strict: true)
       locales.inject(empty_forest) do |forest, locale|
-        forest.merge! missing_used_tree(locale)
+        forest.merge! missing_used_tree(locale, used: used)
       end
     end
 
@@ -83,13 +84,7 @@ module I18n::Tasks
       @plural_keys_for_locale ||= {}
       return @plural_keys_for_locale[locale] if @plural_keys_for_locale.key?(locale)
 
-      @plural_keys_for_locale[locale] = plural_keys_for_locale(locale)
-    end
-
-    # 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")
-      eval(File.read(path), binding, path) # rubocop:disable Security/Eval
+      @plural_keys_for_locale[locale] = Set.new(rails_i18n_plural_config(locale)&.dig(:keys) || [])
     end
 
     # keys present in compared_to, but not in locale
@@ -107,8 +102,9 @@ module I18n::Tasks
     end
 
     # keys used in the code missing translations in locale
-    def missing_used_tree(locale)
-      used_tree(strict: true).select_keys do |key, node|
+    def missing_used_tree(locale, used: nil)
+      used ||= used_tree(strict: true)
+      used.select_keys do |key, node|
         occurrences = node.data[:occurrences] || []
 
         # An occurrence may carry candidate keys (for relative lookups). If any
@@ -138,7 +134,7 @@ module I18n::Tasks
     end
 
     def locale_key_missing?(locale, key)
-      !key_value?(key, locale) && !external_key?(key, locale) && !ignore_key?(key, :missing)
+      !key_value?(key, locale) && !external_key?(key, locale) && !ignore_key?(key, :missing, locale)
     end
 
     # @param [::I18n::Tasks::Data::Tree::Siblings] forest
@@ -170,32 +166,5 @@ module I18n::Tasks
       end
       forest
     end
-
-    private
-
-    def plural_keys_for_locale(locale)
-      configuration = load_rails_i18n_pluralization!(locale)
-      if configuration[locale.to_sym].nil?
-        alternate_locale = alternate_locale_from(locale)
-        return Set.new if configuration[alternate_locale.to_sym].nil?
-
-        return set_from_rails_i18n_pluralization(configuration, alternate_locale)
-      end
-      set_from_rails_i18n_pluralization(configuration, locale)
-    rescue SystemCallError, IOError
-      Set.new
-    end
-
-    def alternate_locale_from(locale)
-      re = /(\w{2})-*(\w{2,3})*/
-      match = locale.match(re)
-      language_code = match[1]
-      country_code = match[2]
-      "#{language_code}-#{country_code.upcase}"
-    end
-
-    def set_from_rails_i18n_pluralization(configuration, locale)
-      Set.new(configuration[locale.to_sym][:i18n][:plural][:keys])
-    end
   end
 end

data/lib/i18n/tasks/plural_keys.rb

@@ -60,4 +60,60 @@ module I18n::Tasks::PluralKeys
   def plural_suffix?(key)
     PLURAL_KEY_SUFFIXES.include?(key) || EXPLICIT_0_1.include?(key)
   end
+
+  # @param [String] locale
+  # @return [Hash, nil] the rails-i18n plural configuration of the locale (`:keys` and `:rule`), nil if it has none.
+  def rails_i18n_plural_config(locale)
+    @rails_i18n_plural_configs ||= {}
+    return @rails_i18n_plural_configs[locale] if @rails_i18n_plural_configs.key?(locale)
+
+    @rails_i18n_plural_configs[locale] = begin
+      configuration = load_rails_i18n_pluralization!(locale)
+      configuration = configuration[locale.to_sym] || configuration[alternate_locale_from(locale).to_sym]
+      configuration&.dig(:i18n, :plural)
+    rescue SystemCallError, IOError
+      nil
+    end
+  end
+
+  # 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")
+    eval(File.read(path), binding, path) # rubocop:disable Security/Eval
+  end
+
+  # Counts from 0 up to this cover every plural rule in rails-i18n, as they look at `n % 100` at most.
+  PLURAL_RULE_COUNTS = (0..1000)
+
+  # @param [String] locale
+  # @param [Array<String>] form_keys the plural forms of a group in the locale
+  # @return [Hash{String => Integer}, nil] how many counts in PLURAL_RULE_COUNTS select each form,
+  #   with the locale's rails-i18n rule, nil if the locale has no rule.
+  def plural_form_counts(locale, form_keys)
+    rule = rails_i18n_plural_config(locale)&.dig(:rule)
+    return unless rule.respond_to?(:call)
+
+    @plural_form_counts ||= {}
+    @plural_form_counts[[locale, form_keys.sort]] ||=
+      PLURAL_RULE_COUNTS.map { |count| plural_form_for_count(rule, form_keys, count) }.tally
+  end
+
+  private
+
+  # The form I18n::Backend::Pluralization picks for the count.
+  def plural_form_for_count(rule, form_keys, count)
+    return "zero" if count.zero? && form_keys.include?("zero")
+    return count.to_s if count <= 1 && form_keys.include?(count.to_s)
+
+    category = rule.call(count).to_s
+    form_keys.include?(category) ? category : "other"
+  end
+
+  def alternate_locale_from(locale)
+    re = /(\w{2})-*(\w{2,3})*/
+    match = locale.match(re)
+    language_code = match[1]
+    country_code = match[2]
+    "#{language_code}-#{country_code&.upcase}"
+  end
 end

data/lib/i18n/tasks/prune.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module I18n::Tasks::Prune
+  def prunable_keys(base_locale:, locales:)
+    diff_forest = empty_forest
+    locales.each do |locale|
+      # Based on the docs, missing_diff_tree only returns keys that are in the second argument but not in the first
+      locale_forest =
+        missing_diff_tree(base_locale, locale).tap do |locale_forest|
+          locale_forest.mv_key!(compile_key_pattern(base_locale), locale, root: true)
+        end
+
+      diff_forest.merge!(locale_forest)
+    end
+
+    diff_forest
+  end
+end

data/lib/i18n/tasks/references.rb

@@ -7,7 +7,7 @@ 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? }))
+      data_refs = merge_reference_trees(reference_trees))
       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)
 
@@ -30,6 +30,14 @@ module I18n::Tasks
 
     private
 
+    # Selecting the references of each locale before merging gives the same forest as
+    # data_forest.select_keys, without deep-copying every locale tree first.
+    def reference_trees
+      locales.inject(empty_forest) do |forest, locale|
+        forest.merge!(data[locale].select_keys { |_, node| node.reference? })
+      end
+    end
+
     # @param [I18n::Tasks::Data::Tree::Node] ref
     # @param [I18n::Tasks::Data::Tree::Node] usage
     # @param [I18n::Tasks::Data::Tree::Siblings] raw_refs

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

@@ -12,7 +12,8 @@ module I18n::Tasks::Scanners::AstMatchers
 
     protected
 
-    # If the node type is of `%i(sym str int false true)`, return the value as a string.
+    # If the node type is of `%i(sym str int false true)`, or a `dstr` of string literals only
+    # (see `adjacent_string_literals?`), return the value as a string.
     # Otherwise, if `config[:strict]` is `false` and the type is of `%i(dstr dsym)`,
     # return the source as if it were a string.
     #
@@ -43,6 +44,8 @@ module I18n::Tasks::Scanners::AstMatchers
           # `nil` is returned when a dynamic value is encountered in strict mode. Propagate:
           return nil if str.nil?
         end
+      elsif adjacent_string_literals?(node)
+        node.children.map { |child| child.children[0] }.join
       elsif !@scanner.config[:strict] && %i[dsym dstr].include?(node.type)
         node.children.map do |child|
           if %i[sym str].include?(child.type)
@@ -54,6 +57,12 @@ module I18n::Tasks::Scanners::AstMatchers
       end
     end
 
+    # Adjacent string literals, e.g. `"a.b" \ ".c"`, and multi-line string literals are parsed
+    # as a `dstr` of `str` parts only: they are as static as a `str`.
+    def adjacent_string_literals?(node)
+      node.type == :dstr && node.children.any? && node.children.all? { |child| child.type == :str }
+    end
+
     # Extract the whole hash from a node of type `:hash`
     #
     # @param node [AST::Node] a node of type `:hash`.
@@ -93,7 +102,7 @@ module I18n::Tasks::Scanners::AstMatchers
     # @return [String, nil] `nil` is returned only when a dynamic value is encountered in strict mode.
     def extract_array_as_string(node, array_join_with:, array_flatten: false, array_reject_blank: false)
       children_strings = node.children.map do |child|
-        if %i[sym str int true false].include?(child.type)
+        if %i[sym str int true false].include?(child.type) || adjacent_string_literals?(child)
           extract_string child
         else
           # ignore dynamic argument in strict mode

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

@@ -20,9 +20,23 @@ module I18n::Tasks::Scanners::AstMatchers
 
       value = children[2]
 
+      # Only process static string/symbol arguments; dynamic args (dstr/dsym) cannot be
+      # statically resolved and would produce a bogus key (e.g. "activerecord.attributes.product.").
+      return if value.nil?
+      return unless %i[str sym].include?(value.type) || adjacent_string_literals?(value)
+
       model_name = underscore(receiver.to_a.last)
       attribute = extract_string(value)
-      key = "activerecord.attributes.#{model_name}.#{attribute}"
+      # Convert dots to slashes to match Rails' human_attribute_name behavior
+      # Rails converts "status.active" in Product.human_attribute_name("status.active")
+      # to look for activerecord.attributes.product/status.active
+      # The first dot becomes a slash: model_name.attribute -> model_name/first_part.rest
+      key = if attribute&.include?(".")
+        # Replace model_name.attribute with model_name/attribute for nested lookups
+        "activerecord.attributes.#{model_name}/#{attribute}"
+      else
+        "activerecord.attributes.#{model_name}.#{attribute}"
+      end
       [
         key,
         I18n::Tasks::Scanners::Results::Occurrence.from_range(
@@ -61,7 +75,7 @@ module I18n::Tasks::Scanners::AstMatchers
     end
 
     def underscore(value)
-      value = value.dup.to_s
+      value = value.to_s.dup
       value.gsub!(/(.)([A-Z])/, '\1_\2')
       value.downcase!
     end

data/lib/i18n/tasks/scanners/erb_ast_scanner.rb

@@ -83,7 +83,7 @@ module I18n::Tasks::Scanners
     # Prism scanner, method called in RubyScanner
     def prism_parse_file(path)
       occurrences = []
-      content = File.read(path)
+      content = read_file(path)
 
       content.scan(DEFAULT_REGEXP) do |indicator, code, _tailch, _rspace|
         match = Regexp.last_match
@@ -104,7 +104,7 @@ module I18n::Tasks::Scanners
     def process_code(path, code, content, start)
       return [] if code.strip.empty? # skip empty ERB tags
 
-      process_prism_results(path, Prism.parse(code)).map do |key, occurrence|
+      process_prism_results(path, Prism.parse(code, **PRISM_PARSE_OPTIONS)).map do |key, occurrence|
         [
           key,
           occurrence_from_position(
@@ -121,7 +121,10 @@ module I18n::Tasks::Scanners
     def process_comments(path, code, content, start)
       return [] if code.strip.empty?
 
-      parsed = Prism.parse(code.gsub("i18n-tasks-use ", "#i18n-tasks-use "))
+      # ERB comments are not executed, so only the `i18n-tasks-use` magic comments
+      # inside them are relevant. Turn every line into a Ruby comment so that
+      # commented-out code (e.g. `<%# t("key") %>`) is not reported as used.
+      parsed = Prism.parse(code.each_line.map { |line| "##{line.sub(/\A[ \t#]*/, "")}" }.join, **PRISM_PARSE_OPTIONS)
       process_prism_results(path, parsed).map do |key, occurrence|
         [
           key,

data/lib/i18n/tasks/scanners/file_scanner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "i18n/tasks/scanners/scanner"
+require "i18n/tasks/scanners/files/parse_cache"
 
 module I18n::Tasks::Scanners
   # A base class for a scanner that analyses files.
@@ -13,11 +14,13 @@ module I18n::Tasks::Scanners
     def initialize(
       config: {},
       file_finder_provider: Files::CachingFileFinderProvider.new,
-      file_reader: Files::CachingFileReader.new
+      file_reader: Files::CachingFileReader.new,
+      parse_cache: Files::ParseCache.new
     )
       super()
       @config = config
       @file_reader = file_reader
+      @parse_cache = parse_cache
       @file_finder = file_finder_provider.get(**config.slice(:paths, :only, :exclude))
     end
 

data/lib/i18n/tasks/scanners/files/file_finder.rb

@@ -11,14 +11,14 @@ module I18n::Tasks::Scanners::Files
     #     absolute or relative to the working directory.
     # @param only [Array<String>, nil] {File.fnmatch}-compatible patterns files to include.
     #     Files not matching any of the inclusion patterns will be excluded.
-    # @param exclude [Arry<String>] {File.fnmatch}-compatible patterns of files to exclude.
+    # @param exclude [Array<String>] {File.fnmatch}-compatible patterns of files to exclude.
     #     Files matching any of the exclusion patterns will be excluded even if they match an inclusion pattern.
     def initialize(paths: ["."], only: nil, exclude: [])
       fail "paths argument is required" if paths.nil?
 
       @paths = paths
-      @include = only
-      @exclude = exclude || []
+      @include = only && split_extension_globs(only)
+      @exclude = split_extension_globs(exclude || [])
     end
 
     # Traverse the paths and yield the matching ones.
@@ -51,11 +51,34 @@ module I18n::Tasks::Scanners::Files
 
     private
 
+    # Paths found under `.` start with `./`, which neither `*.rb` nor `app/**` match: try them without it too.
     # @param path [String]
-    # @param globs [Array<String>]
+    # @param split_globs [Array(Array<String>, Array<String>)] from {#split_extension_globs}
+    # @return [Boolean]
+    def path_fnmatch_any?(path, split_globs)
+      path_fnmatch_split_globs?(path, split_globs) ||
+        (path.start_with?("./") && path_fnmatch_split_globs?(path.delete_prefix("./"), split_globs))
+    end
+
+    # `File.fnmatch("*.png", path)` is `path.end_with?(".png")`, except for a path starting with a dot,
+    # which `*` does not match without `File::FNM_DOTMATCH`.
+    # @param path [String]
+    # @param split_globs [Array(Array<String>, Array<String>)] from {#split_extension_globs}
     # @return [Boolean]
-    def path_fnmatch_any?(path, globs)
-      globs.any? { |glob| File.fnmatch(glob, path) }
+    def path_fnmatch_split_globs?(path, split_globs)
+      suffixes, other_globs = split_globs
+      (!path.start_with?(".") && path.end_with?(*suffixes)) ||
+        other_globs.any? { |glob| File.fnmatch(glob, path) }
+    end
+
+    # ASCII only: `String#end_with?` raises on incompatible encodings, where `File.fnmatch` returns false.
+    EXTENSION_GLOB = /\A\*(\.[\w-]+)+\z/
+
+    # @param globs [Array<String>]
+    # @return [Array(Array<String>, Array<String>)] the suffixes of the extension globs, and the other globs
+    def split_extension_globs(globs)
+      extension_globs, other_globs = globs.partition { |glob| EXTENSION_GLOB.match?(glob) }
+      [extension_globs.map { |glob| glob.delete_prefix("*") }, other_globs]
     end
   end
 end

data/lib/i18n/tasks/scanners/files/parse_cache.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "i18n/tasks/concurrent/cache"
+
+module I18n::Tasks::Scanners::Files
+  # Keeps the files parsed while {#retain} runs, so that scanning them again
+  # (strictly, then non-strictly) does not parse them twice.
+  #
+  # @note This class is thread-safe.
+  class ParseCache
+    def retain
+      @cache = ::I18n::Tasks::Concurrent::Cache.new
+      yield
+    ensure
+      @cache = nil
+    end
+
+    # @param key [Object] identifies the parse, e.g. the scanner class and the path.
+    # @yieldreturn the parse, computed only if not retained.
+    def fetch(key, &)
+      @cache ? @cache.fetch(key, &) : yield
+    end
+  end
+end

data/lib/i18n/tasks/scanners/prism_scanners/arguments_visitor.rb

@@ -16,11 +16,27 @@ module I18n::Tasks::Scanners::PrismScanners
       end
     end
 
+    def visit_local_variable_read_node(node)
+      # Keep this node to know that we cannot resolve this argument statically
+      node
+    end
+
+    def visit_constant_read_node(node)
+      # Keep this node to know that we cannot resolve this argument statically
+      node
+    end
+
     # Cannot handle arguments that are calls
     def visit_call_node(_node)
       nil
     end
 
+    # Shorthand hash syntax (e.g. `scope:` as shorthand for `scope: scope`) wraps
+    # the implicit value in an ImplicitNode — delegate to the inner node.
+    def visit_implicit_node(node)
+      visit(node.value)
+    end
+
     def visit_symbol_node(node)
       node.value
     end
@@ -29,6 +45,23 @@ module I18n::Tasks::Scanners::PrismScanners
       node.content
     end
 
+    # Interpolated nodes (e.g. `Product.human_attribute_name("status.#{status}")`) contain dynamic content that cannot
+    # be statically resolved: return nil. Adjacent string literals (e.g. `"a.b" \ ".c"`) are parsed as an
+    # interpolated node too, but are static.
+    def visit_interpolated_string_node(node)
+      return unless node.parts.all?(Prism::StringNode)
+
+      node.parts.map(&:content).join
+    end
+
+    def visit_interpolated_symbol_node(_node)
+      nil
+    end
+
+    def visit_interpolated_x_string_node(_node)
+      nil
+    end
+
     def visit_array_node(node)
       node.child_nodes.map { |child| visit(child) }
     end