i18n-tasks 1.0.15 → 1.1.0

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

@@ -1,29 +1,28 @@
 # frozen_string_literal: true
 
-require 'prism/visitor'
-require_relative 'nodes'
-require_relative 'arguments_visitor'
+require "prism/visitor"
+require_relative "nodes"
+require_relative "arguments_visitor"
 
 # Implementation of Prism::Visitor (https://ruby.github.io/prism/rb/Prism/Visitor.html)
 # It processes the parsed AST from Prism and creates a new AST with the nodes defined in prism_scanners/nodes.rb
-# The only argument it receives is comments, which can be used for magic comments.
 # It defines processing of arguments in a way that is needed for the translation calls.
-# Any Rails-specific processing is added in the RailsVisitor class.
+# The argument `rails` is used to determine if the scanner should handle Rails specific calls, such as
+# `before_action`, `human_attribute_name`, and `model_name.human`.
 
 module I18n::Tasks::Scanners::PrismScanners
   class Visitor < Prism::Visitor # rubocop:disable Metrics/ClassLength
-    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/.freeze
+    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/
 
     attr_reader(:calls, :current_module, :current_class, :current_method, :root)
 
-    def initialize(comments: nil, rails: false)
+    def initialize(rails: false, file_path: nil)
       @calls = []
-      @comment_translations_by_row = prepare_comments_by_line(comments)
 
       @current_module = nil
       @current_class = nil
       @current_method = nil
-      @root = Root.new
+      @root = Root.new(file_path:, rails: rails)
 
       @rails = rails
 
@@ -35,47 +34,24 @@ module I18n::Tasks::Scanners::PrismScanners
       @current_before_action || @current_method || @current_class || @current_module || @root
     end
 
-    def prepare_comments_by_line(comments)
-      return {} if comments.nil?
-
-      comments.each_with_object({}) do |comment, by_row|
-        content =
-          comment.respond_to?(:slice) ? comment.slice : comment.location.slice
-        match = content.match(MAGIC_COMMENT_PREFIX)
-
-        next by_row if match.nil?
-
-        string =
-          content.gsub(MAGIC_COMMENT_PREFIX, '').gsub('#', '').strip
-        visitor = Visitor.new
-        Prism
-          .parse(string)
-          .value
-          .accept(visitor)
-
-        nodes = visitor.process
-
-        next by_row if nodes.empty?
-
-        # Remap the found translation calls to be for the found comment
-        nodes = nodes.map { |node| node.with_node(comment) }
-
-        by_row[comment.location.start_line] = nodes
-        by_row
-      end
-    end
-
     def visit_module_node(node)
       previous_module = @current_module
       @current_module = parent.add_child(
         ParsedModule.new(node: node, parent: parent)
       )
 
+      handle_comments(node)
+
       super
     ensure
       @current_module = previous_module
     end
 
+    def visit_program_node(node)
+      handle_comments(node)
+      super
+    end
+
     def visit_class_node(node)
       previous_class = @current_class
 
@@ -87,12 +63,15 @@ module I18n::Tasks::Scanners::PrismScanners
         )
       )
 
+      handle_comments(node)
+
       super
     ensure
       @current_class = previous_class
     end
 
     def visit_def_node(node)
+      handle_comments(node)
       previous_method = @current_method
       parent = @current_class || @current_module || @root
       @current_method = parent.add_child(
@@ -115,7 +94,6 @@ module I18n::Tasks::Scanners::PrismScanners
       when :private
         @current_class&.private_methods!
       when :t, :t!, :translate, :translate!
-
         args, kwargs = process_arguments(node)
         parent.add_translation_call(
           TranslationCall.new(
@@ -127,24 +105,18 @@ module I18n::Tasks::Scanners::PrismScanners
           )
         )
       else
-        if @rails
-          return rails_call_node(node) do
-            super
-          end || parent.add_call(node)
-        else
-          parent.add_call(node)
-        end
+        handled_call = handle_rails_call_node(node) { super } if @rails
+
+        return if handled_call
+
+        parent.add_call(node)
+
       end
 
       super
     end
 
     def process
-      @comment_translations_by_row.each_value do |nodes|
-        nodes.each do |node|
-          @root.add_translation_call(node)
-        end
-      end
       @root.process
     end
 
@@ -163,27 +135,94 @@ module I18n::Tasks::Scanners::PrismScanners
     end
 
     def handle_comments(node)
-      comments = @comment_translations_by_row[node.location.start_line - 1]
-      comments&.each do |comment|
-        parent.add_translation_call(comment.with_node(node))
-        @comment_translations_by_row.delete(node.location.start_line - 1)
+      return if node.nil?
+      return if node.comments.empty?
+
+      node.comments.each do |comment|
+        content =
+          comment.respond_to?(:slice) ? comment.slice : comment.location.slice
+        match = content.match(MAGIC_COMMENT_PREFIX)
+
+        next if match.nil?
+
+        string =
+          content.gsub(MAGIC_COMMENT_PREFIX, "").delete("#").strip
+        visitor = Visitor.new
+        Prism
+          .parse(string)
+          .value
+          .accept(visitor)
+
+        # Process and remap the found translation calls to be for the found comment
+        visitor.process.each do |comment_node|
+          parent.add_translation_call(comment_node.with_node(node))
+        end
       end
     end
 
     # ---- Rails specific methods ----
     # Returns true if the node was handled
-    def rails_call_node(node, &block)
+    def handle_rails_call_node(node, &)
+      # First, handle calls that should be matched everywhere
       case node.name
-      when :before_action
-        rails_handle_before_action(node, &block)
-        true
       when :human_attribute_name
         rails_handle_human_attribute_name(node)
-        true
+        return true
       when :human
-        return false if node.receiver.name != :model_name
-
+        return false if node.receiver.nil? || node.receiver.name != :model_name
         rails_handle_model_name(node)
+        return true
+      end
+
+      if @current_class&.controller?
+        rails_handle_controller_call_node(node, &)
+      elsif @current_class&.mailer?
+        rails_handle_mailer_call_node(node, &)
+      else
+        false
+      end
+    end
+
+    def rails_handle_controller_call_node(node, &)
+      case node.name
+      when :before_action
+        rails_handle_before_action(node, &)
+        true
+      else
+        false
+      end
+    end
+
+    def rails_handle_mailer_call_node(node, &)
+      case node.name
+      when :mail
+        _array_args, keywords = process_arguments(node)
+        if keywords.key?("subject")
+          # Let traversal continue so nested calls (e.g., t('.subject') or default_i18n_subject)
+          # get processed by their own handlers.
+          false
+        else
+          parent.add_translation_call(
+            TranslationCall.new(
+              node: node,
+              receiver: nil,
+              key: ".subject",
+              parent: parent,
+              options: {}
+            )
+          )
+          true
+        end
+      when :default_i18n_subject
+        parent.add_translation_call(
+          TranslationCall.new(
+            node: node,
+            receiver: nil,
+            key: ".subject",
+            parent: parent,
+            options: {}
+          )
+        )
         true
       else
         false
@@ -191,36 +230,32 @@ module I18n::Tasks::Scanners::PrismScanners
     end
 
     def rails_handle_before_action(node) # rubocop:disable Metrics/MethodLength
+      before_action = ParsedBeforeAction.new(
+        node: node,
+        parent: @current_class
+      )
+      @current_class&.add_child(before_action)
+      # Need to set current_before_action before processing arguments
+      # since they can be lambdas that need to be processed in the context of the before_action
+      @current_before_action = before_action
       array_arguments, keywords = process_arguments(node)
       first_argument = array_arguments.first
 
-      before_action = if array_arguments.empty? && node.block.present?
-                        ParsedBeforeAction.new(
-                          node: node,
-                          parent: parent
-                        )
-                      elsif first_argument.is_a?(String)
-                        ParsedBeforeAction.new(
-                          node: node,
-                          parent: parent,
-                          name: first_argument,
-                          only: keywords['only'],
-                          except: keywords['except']
-                        )
-                      elsif first_argument.try(:type) == :lambda_node
-                        ParsedBeforeAction.new(
-                          node: node,
-                          parent: parent,
-                          only: keywords['only'],
-                          except: keywords['except']
-                        )
-                      else
-                        fail(
-                          ArgumentError,
-                          "Cannot handle before_action with this argument #{first_argument.class}"
-                        )
-                      end
-      @current_before_action = parent&.add_child(before_action)
+      if array_arguments.empty? && node.block.present?
+        # No need to add data
+      elsif first_argument.is_a?(String)
+        before_action.name = first_argument
+        before_action.only = keywords["only"]
+        before_action.except = keywords["except"]
+      elsif first_argument.try(:type) == :lambda_node
+        before_action.only = keywords["only"]
+        before_action.except = keywords["except"]
+      else
+        fail(
+          ArgumentError,
+          "Cannot handle before_action with this argument #{first_argument.class}"
+        )
+      end
 
       yield
     ensure
@@ -229,36 +264,65 @@ module I18n::Tasks::Scanners::PrismScanners
 
     def rails_handle_model_name(node)
       _args, kwargs = process_arguments(node)
-      model_name = node.receiver.receiver.name.to_s.underscore
 
-      count_key = (kwargs['count'] || 0) > 1 ? 'other' : 'one'
+      # We need to check for `node.receiver` since node is the `human` call
+      model_name = if current_class.present? && rails_model_method_called_on_current_class?(node.receiver)
+        current_class.path.flatten.map!(&:underscore).join(".")
+      elsif node.receiver.present?
+        node.receiver&.receiver&.name&.to_s&.underscore
+      end
+
+      return if model_name.nil?
+
+      # Handle count being a symbol, e.g. count: :other
+      count_key = case kwargs["count"]
+      when Integer
+        (kwargs["count"] > 1) ? "other" : "one"
+      when "one", :one, nil
+        "one"
+      else
+        "other"
+      end
+
       parent.add_translation_call(
         TranslationCall.new(
           node: node,
           receiver: nil,
-          key: [:activerecord, :models, model_name, count_key].join('.'),
+          key: [:activerecord, :models, model_name, count_key].join("."),
           parent: parent,
           options: kwargs
         )
       )
     end
 
+    def rails_model_method_called_on_current_class?(node)
+      node.receiver.nil? || (node.receiver&.name&.to_s == "class" && node.receiver.receiver&.is_a?(Prism::SelfNode))
+    end
+
     def rails_handle_human_attribute_name(node)
       array_args, keywords = process_arguments(node)
-      unless array_args.size == 1 && keywords.empty?
-        fail(
-          ArgumentError,
-          'human_attribute_name should have only one argument'
-        )
+      # Arguments empty or cannot be processed, e.g. if it is a call
+      return unless array_args.size == 1 && keywords.empty?
+
+      # Handle if called on `self.class` or if the current_class has `model_name.i18n_key`
+      key = if current_class.present? && rails_model_method_called_on_current_class?(node)
+        [
+          :activerecord,
+          :attributes,
+          current_class.path.flatten.map!(&:underscore).join("."),
+          array_args.first
+        ].join(".")
+      elsif node.receiver&.name.present?
+        [
+          :activerecord,
+          :attributes,
+          node.receiver.name.to_s.underscore,
+          array_args.first
+        ].join(".")
+      else
+        return
       end
 
-      key = [
-        :activerecord,
-        :attributes,
-        node.receiver.name.to_s.underscore,
-        array_args.first
-      ].join('.')
-
       parent.add_translation_call(
         TranslationCall.new(
           node: node,

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

@@ -10,16 +10,16 @@ module I18n
         # @param calling_method [#call, Symbol, String, false, nil]
         # @return [String] absolute version of the key
         def absolute_key(key, path, roots: config[:relative_roots],
-                         exclude_method_name_paths: config[:relative_exclude_method_name_paths],
-                         calling_method: nil)
+          exclude_method_name_paths: config[:relative_exclude_method_name_paths],
+          calling_method: nil)
           return key unless key.start_with?(DOT)
-          fail 'roots argument is required' unless roots.present?
+          fail "roots argument is required" unless roots.present?
 
           normalized_path = File.expand_path(path)
           (root = path_root(normalized_path, roots)) ||
             fail(CommandError, "Cannot resolve relative key \"#{key}\".\n" \
                                "Set search.relative_roots in config/i18n-tasks.yml (currently #{roots.inspect})")
-          normalized_path.sub!(root, '')
+          normalized_path.sub!(root, "")
 
           if (exclude_method_name_paths || []).map { |p| expand_path(p) }.include?(root)
             "#{prefix(normalized_path)}#{key}"
@@ -30,7 +30,7 @@ module I18n
 
         private
 
-        DOT = '.'
+        DOT = "."
 
         # Detect the appropriate relative path root
         # @param [String] path /full/path
@@ -54,14 +54,14 @@ module I18n
         # @param normalized_path [String] path/relative/to/a/root
         # @param calling_method [#call, Symbol, String, false, nil]
         def prefix(normalized_path, calling_method: nil)
-          file_key       = normalized_path.gsub(%r{(\.[^/]+)*$}, '').tr(File::SEPARATOR, DOT)
+          file_key = normalized_path.gsub(%r{(\.[^/]+)*$}, "").tr(File::SEPARATOR, DOT)
           calling_method = calling_method.call if calling_method.respond_to?(:call)
           if calling_method&.present?
             # Relative keys in mailers have a `_mailer` infix, but relative keys in controllers do not have one:
-            "#{file_key.sub(/_controller$/, '')}.#{calling_method}"
+            "#{file_key.sub(/_controller$/, "")}.#{calling_method}"
           else
             # Remove _ prefix from partials
-            file_key.gsub('._', DOT)
+            file_key.gsub("._", DOT)
           end
         end
       end

data/lib/i18n/tasks/scanners/results/key_occurrences.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::Results
   # A scanned key and all its occurrences.
@@ -14,7 +14,7 @@ module I18n::Tasks::Scanners::Results
     attr_reader :occurrences
 
     def initialize(key:, occurrences:)
-      @key         = key
+      @key = key
       @occurrences = occurrences
     end
 
@@ -31,7 +31,7 @@ module I18n::Tasks::Scanners::Results
     end
 
     def inspect
-      "KeyOccurrences(#{key.inspect}, [#{occurrences.map(&:inspect).join(', ')}])"
+      "KeyOccurrences(#{key.inspect}, [#{occurrences.map(&:inspect).join(", ")}])"
     end
 
     # Merge {KeyOccurrences} in an {Enumerable<KeyOccurrences>} so that in the resulting {Array<KeyOccurrences>}:

data/lib/i18n/tasks/scanners/results/occurrence.rb

@@ -28,6 +28,9 @@ module I18n::Tasks
         # @return [String, nil] the raw key (for relative keys and references)
         attr_accessor :raw_key
 
+        # @return [Array<String>, nil] candidate keys that may be used at runtime
+        attr_reader :candidate_keys
+
         # @param path        [String]
         # @param pos         [Integer]
         # @param line_num    [Integer]
@@ -36,24 +39,25 @@ module I18n::Tasks
         # @param raw_key     [String, nil]
         # @param default_arg [String, nil]
         # rubocop:disable Metrics/ParameterLists
-        def initialize(path:, pos:, line_num:, line_pos:, line:, raw_key: nil, default_arg: nil)
-          @path        = path
-          @pos         = pos
-          @line_num    = line_num
-          @line_pos    = line_pos
-          @line        = line
-          @raw_key     = raw_key
+        def initialize(path:, pos:, line_num:, line_pos:, line:, raw_key: nil, default_arg: nil, candidate_keys: nil)
+          @path = path
+          @pos = pos
+          @line_num = line_num
+          @line_pos = line_pos
+          @line = line
+          @raw_key = raw_key
           @default_arg = default_arg
+          @candidate_keys = candidate_keys
         end
         # rubocop:enable Metrics/ParameterLists
 
         def inspect
-          "Occurrence(#{@path}:#{@line_num}, line_pos: #{@line_pos}, pos: #{@pos}, raw_key: #{@raw_key}, default_arg: #{@default_arg}, line: #{@line})" # rubocop:disable Layout/LineLength
+          "Occurrence(#{@path}:#{@line_num}, line_pos: #{@line_pos}, pos: #{@pos}, raw_key: #{@raw_key}, candidate_keys: #{@candidate_keys}, default_arg: #{@default_arg}, line: #{@line})" # rubocop:disable Layout/LineLength
         end
 
         def ==(other)
           other.path == @path && other.pos == @pos && other.line_num == @line_num && other.line == @line &&
-            other.raw_key == @raw_key && other.default_arg == @default_arg
+            other.raw_key == @raw_key && other.default_arg == @default_arg && other.candidate_keys == @candidate_keys
         end
 
         def eql?(other)
@@ -61,7 +65,7 @@ module I18n::Tasks
         end
 
         def hash
-          [@path, @pos, @line_num, @line_pos, @line, @default_arg].hash
+          [@path, @pos, @line_num, @line_pos, @line, @default_arg, @candidate_keys].hash
         end
 
         # @param raw_key [String]

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'ast'
+require "ast"
 
 module I18n::Tasks::Scanners
   class RubyAstCallFinder

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

@@ -2,7 +2,7 @@
 
 module I18n::Tasks::Scanners
   module RubyKeyLiterals
-    LITERAL_RE = /:?".+?"|:?'.+?'|:\w+/.freeze
+    LITERAL_RE = /:?".+?"|:?'.+?'|:\w+/
 
     # Match literals:
     # * String: '', "#{}"
@@ -15,16 +15,16 @@ module I18n::Tasks::Scanners
     # @param literal [String] e.g: "key", 'key', or :key.
     # @return [String] key
     def strip_literal(literal)
-      literal = literal[1..] if literal[0] == ':'
-      literal = literal[1..-2] if literal[0] == "'" || literal[0] == '"'
+      literal = literal[1..] if literal[0] == ":"
+      literal = literal[1..-2] if ["'", '"'].include?(literal[0])
       literal
     end
 
-    VALID_KEY_CHARS = %r{(?:[[:word:]]|[-.?!:;À-ž\\/]|(?<=[\p{L}\d])\s(?=[\p{L}\d]))}.freeze
-    VALID_KEY_RE    = /^#{VALID_KEY_CHARS}+$/.freeze
+    VALID_KEY_CHARS = %r{(?:[[:word:]]|[-.?!:;À-ž\\/]|(?<=[\p{L}\d])\s(?=[\p{L}\d]))}
+    VALID_KEY_RE = /^#{VALID_KEY_CHARS}+$/
 
     def valid_key?(key)
-      key =~ VALID_KEY_RE && !key.end_with?('.')
+      key =~ VALID_KEY_RE && !key.end_with?(".")
     end
   end
 end

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

@@ -18,7 +18,7 @@ module I18n::Tasks::Scanners
     def self.create_parser
       prev = $VERBOSE
       $VERBOSE = nil
-      require 'parser/current'
+      require "parser/current"
       ::Parser::CurrentRuby.new
     ensure
       $VERBOSE = prev