i18n-tasks 1.0.14 → 1.1.0

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

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+# These classes are used in the PrismScanners::Visitor class to store the translations found in the parsed code
+# Used in the PrismScanners::Visitor class.
+module I18n::Tasks::Scanners::PrismScanners
+  class Root
+    attr_reader(:calls, :translation_calls, :children, :node, :parent, :rails, :file_path)
+
+    def initialize(node: nil, parent: nil, file_path: nil, rails: false)
+      @calls = []
+      @translation_calls = []
+      @children = []
+      @node = node
+      @parent = parent
+      @rails = rails
+      @file_path = file_path
+    end
+
+    def add_child(node)
+      @children << node
+      node
+    end
+
+    def add_call(node)
+      @calls << node
+    end
+
+    def add_translation_call(translation_call)
+      @translation_calls += Array(translation_call)
+    end
+
+    def rails_view?
+      rails && file_path.present? && file_path.include?("app/views/")
+    end
+
+    def partial_view?
+      file_path.present? && File.basename(file_path).start_with?("_")
+    end
+
+    def support_relative_keys?
+      rails_view? && !partial_view?
+    end
+
+    def path
+      if rails_view?
+        folder_path = file_path.sub(%r{app/views/}, "").split("/")
+        name = folder_path.pop.split(".").first
+
+        [*folder_path, name]
+      else
+        []
+      end
+    end
+
+    def process
+      (@translation_calls + @children.flat_map(&:process)).flatten
+    end
+
+    # Only supported for Rails controllers currently
+    def private_method
+      false
+    end
+  end
+
+  class TranslationCall
+    class ScopeError < StandardError; end
+    attr_reader(:node, :key, :receiver, :options, :parent)
+
+    def initialize(node:, key:, receiver:, options:, parent:)
+      @node = node
+      @key = key
+      @receiver = receiver
+      @options = options
+      @parent = parent
+    end
+
+    def relative_key?
+      @key&.start_with?(".") && @receiver.nil?
+    end
+
+    def with_parent(parent)
+      self.class.new(
+        node: @node,
+        key: @key,
+        receiver: @receiver,
+        options: @options,
+        parent: parent
+      )
+    end
+
+    def with_node(node)
+      self.class.new(
+        node: node,
+        key: @key,
+        receiver: @receiver,
+        options: @options,
+        parent: @parent
+      )
+    end
+
+    def occurrences(file_path)
+      occurrence(file_path)
+    end
+
+    # Returns either a single key string or an array of candidate key strings for this call.
+    def full_key
+      return nil if key.nil?
+      return nil unless key.is_a?(String)
+      return nil if relative_key? && !support_relative_keys?
+
+      base_parts = [scope].compact
+
+      if relative_key?
+        # For relative keys in controllers/methods, generate candidate keys by
+        # progressively stripping trailing path segments from the parent path.
+        # Example: parent.path = ["events", "create"], key = ".success"
+        # yields: ["events.create.success", "events.success"]
+        parent_path = parent&.path || []
+        rel_key = key[1..] # strip leading dot # rubocop:disable Performance/ArraySemiInfiniteRangeSlice
+
+        candidates = []
+        parent_path_length = parent_path.length
+        # Do not generate an unscoped bare key (keep_count = 0). Start from full parent path
+        parent_path_length.downto(1) do |keep_count|
+          parts = base_parts + parent_path.first(keep_count) + [rel_key]
+          candidates << parts.compact.join(".")
+        end
+
+        candidates.map { |c| c.gsub("..", ".") }
+      elsif key.start_with?(".")
+        [base_parts + [key[1..]]].flatten.compact.join(".").gsub("..", ".") # rubocop:disable Performance/ArraySemiInfiniteRangeSlice,Performance/ChainArrayAllocation
+      else
+        [base_parts + [key]].flatten.compact.join(".").gsub("..", ".") # rubocop:disable Performance/ChainArrayAllocation
+      end
+    end
+
+    private
+
+    def scope
+      return nil if @options.nil?
+      return nil unless @options["scope"]
+
+      fail(ScopeError, "Could not process scope") if @options.key?("scope") && (Array(@options["scope"]).empty? || !Array(@options["scope"]).all? { |s| s.is_a?(String) || s.is_a?(Symbol) })
+
+      Array(@options["scope"]).join(".")
+    end
+
+    def occurrence(file_path)
+      local_node = @node
+
+      location = local_node.location
+
+      final = full_key
+      return nil if final.nil?
+
+      occurrence = ::I18n::Tasks::Scanners::Results::Occurrence.new(
+        path: file_path,
+        line: local_node.respond_to?(:slice) ? local_node.slice : local_node.location.slice,
+        pos: location.start_offset,
+        line_pos: location.start_column,
+        line_num: location.start_line,
+        raw_key: key
+      )
+
+      # full_key may be a single String or an Array of candidate strings
+      if final.is_a?(Array)
+        # record candidate keys on the occurrence (first candidate is the primary)
+        occurrence.instance_variable_set(:@candidate_keys, final)
+        [final.first, occurrence]
+      else
+        occurrence.instance_variable_set(:@candidate_keys, [final])
+        [final, occurrence]
+      end
+    rescue ScopeError
+      nil
+    end
+
+    # Only public methods are added to the context path
+    # Only some classes supports relative keys
+    def support_relative_keys?
+      (parent.is_a?(ParsedMethod) || parent.is_a?(Root)) && parent.support_relative_keys?
+    end
+  end
+
+  class ParsedModule < Root
+    def support_relative_keys?
+      false
+    end
+
+    def path
+      (@parent&.path || []) + [path_name]
+    end
+
+    def path_name
+      @node.name.to_s.underscore
+    end
+  end
+
+  class ParsedClass < Root
+    attr_reader(:private_method)
+
+    def initialize(node:, parent:, rails:)
+      @private_method = false
+      @methods = []
+      @private_methods = []
+      @before_actions = []
+
+      super
+    end
+
+    def add_child(node)
+      case node
+      when ParsedMethod
+        if @private_method
+          @private_methods << node
+        else
+          @methods << node
+        end
+      when ParsedBeforeAction
+        @before_actions << node
+      end
+
+      super
+    end
+
+    def process # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      if controller?
+        process_controller
+      else
+        super
+      end
+    end
+
+    def process_controller
+      methods_by_name = @methods.group_by(&:name)
+      private_methods_by_name = @private_methods.group_by(&:name)
+
+      # For each before_action we need to
+      # - Find which method it calls
+      # - Find out which methods it applies to
+      # - Calculate translation calls (and see if they are relative)
+      # - Add the translation calls to the methods it applies to
+
+      @before_actions.each do |before_action|
+        before_action_name = before_action.name&.to_sym
+        method_call = methods_by_name[before_action_name]&.first || private_methods_by_name[before_action_name]&.first
+        translation_calls = (method_call&.translation_calls || []) + before_action.translation_calls
+
+        # We need to handle the parent here, should not be the before_action when it is called in the method.
+        @methods.each do |method|
+          next unless before_action.applies_to?(method.name)
+
+          method.add_translation_call(
+            translation_calls.map do |call|
+              call.with_parent(method)
+            end
+          )
+        end
+      end
+
+      nested_calls = {}
+      new_translation_calls = []
+
+      @methods.each do |method|
+        method.calls.each do |call|
+          next if call.receiver.present?
+
+          other_method = methods_by_name[call.name]&.first || private_methods_by_name[call.name]&.first
+          next unless other_method
+
+          nested_calls[method.name] ||= []
+          nested_calls[method.name] << other_method.name
+
+          if nested_calls[call.name]&.include?(method.name)
+            next
+          end
+
+          other_method.translation_calls.each do |translation_call|
+            new_translation_calls.push(translation_call.with_parent(method))
+          end
+        end
+      end
+
+      @translation_calls + @children.flat_map(&:process) + new_translation_calls
+    end
+
+    def private_methods!
+      @private_method = true
+    end
+
+    def support_relative_keys?
+      controller? || mailer?
+    end
+
+    def path
+      (@parent&.path || []) + [path_name]
+    end
+
+    def controller?
+      @rails && @node.name.to_s.end_with?("Controller")
+    end
+
+    def mailer?
+      @rails && @node.name.to_s.end_with?("Mailer")
+    end
+
+    def path_name
+      path = @node.constant_path.full_name_parts.map { |s| s.to_s.underscore }
+      path.last.delete_suffix!("_controller") if controller?
+
+      path
+    end
+  end
+
+  class ParsedMethod < Root
+    def initialize(node:, parent:, private_method: false)
+      @private_method = private_method
+
+      super(node: node, parent: parent)
+    end
+
+    def support_relative_keys?
+      !@private_method && @parent&.support_relative_keys?
+    end
+
+    def path
+      (@parent&.path || []) + [@node.name]
+    end
+
+    def name
+      @node.name
+    end
+
+    def process
+      @translation_calls
+    end
+  end
+
+  class ParsedBeforeAction < Root
+    attr_accessor(:name, :only, :except)
+
+    def initialize(node:, parent:, name: nil, only: nil, except: nil)
+      @name = name
+      @only = only.present? ? Array(only).map(&:to_s) : nil
+      @except = except.present? ? Array(except).map(&:to_s) : nil
+
+      super(node: node, parent: parent)
+    end
+
+    def support_relative_keys?
+      false
+    end
+
+    def applies_to?(method_name)
+      if @only.nil? && @except.nil?
+        true
+      elsif @only.nil?
+        !@except.include?(method_name.to_s)
+      elsif @except.nil?
+        @only.include?(method_name.to_s)
+      else
+        false
+      end
+    end
+
+    def path
+      @parent&.path || []
+    end
+
+    def process
+      @translation_calls.filter { |call| !call.relative_key? }
+    end
+  end
+end

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

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+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
+# It defines processing of arguments in a way that is needed for the translation calls.
+# 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+/
+
+    attr_reader(:calls, :current_module, :current_class, :current_method, :root)
+
+    def initialize(rails: false, file_path: nil)
+      @calls = []
+
+      @current_module = nil
+      @current_class = nil
+      @current_method = nil
+      @root = Root.new(file_path:, rails: rails)
+
+      @rails = rails
+
+      # Needs to have () because the Prism::Visitor has no arguments
+      super()
+    end
+
+    def parent
+      @current_before_action || @current_method || @current_class || @current_module || @root
+    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
+
+      @current_class = parent.add_child(
+        ParsedClass.new(
+          node: node,
+          parent: parent,
+          rails: @rails
+        )
+      )
+
+      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(
+        ParsedMethod.new(
+          node: node,
+          parent: parent,
+          private_method: parent.private_method
+        )
+      )
+
+      super
+    ensure
+      @current_method = previous_method
+    end
+
+    def visit_call_node(node)
+      handle_comments(node)
+
+      case node.name
+      when :private
+        @current_class&.private_methods!
+      when :t, :t!, :translate, :translate!
+        args, kwargs = process_arguments(node)
+        parent.add_translation_call(
+          TranslationCall.new(
+            node: node,
+            key: args[0],
+            receiver: node.receiver,
+            options: kwargs,
+            parent: parent
+          )
+        )
+      else
+        handled_call = handle_rails_call_node(node) { super } if @rails
+
+        return if handled_call
+
+        parent.add_call(node)
+
+      end
+
+      super
+    end
+
+    def process
+      @root.process
+    end
+
+    private
+
+    def process_arguments(node)
+      return [], {} if node.nil?
+      return [], {} unless node.respond_to?(:arguments)
+      return [], {} if node.arguments.nil?
+
+      arguments_visitor = ArgumentsVisitor.new
+      arguments = node.arguments.accept(arguments_visitor)
+      keywords, args = arguments.partition { |arg| arg.is_a?(Hash) }
+
+      [args.compact, keywords.first || {}]
+    end
+
+    def handle_comments(node)
+      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 handle_rails_call_node(node, &)
+      # First, handle calls that should be matched everywhere
+      case node.name
+      when :human_attribute_name
+        rails_handle_human_attribute_name(node)
+        return true
+      when :human
+        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
+      end
+    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
+
+      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
+      @current_before_action = nil
+    end
+
+    def rails_handle_model_name(node)
+      _args, kwargs = process_arguments(node)
+
+      # 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("."),
+          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)
+      # 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
+
+      parent.add_translation_call(
+        TranslationCall.new(
+          node: node,
+          key: key,
+          receiver: nil,
+          parent: parent,
+          options: {}
+        )
+      )
+    end
+  end
+end