i18n-tasks 1.0.14 → 1.0.15

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

@@ -0,0 +1,334 @@
+# 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)
+
+    def initialize(node: nil, parent: nil)
+      @calls = []
+      @translation_calls = []
+      @children = []
+      @node = node
+      @parent = parent
+    end
+
+    def add_child(node)
+      @children << node
+      node
+    end
+
+    def add_call(node)
+      @calls << node
+    end
+
+    def add_translation_call(translation_call)
+      @translation_calls << translation_call
+    end
+
+    def support_relative_keys?
+      false
+    end
+
+    def private_method
+      false
+    end
+
+    def path
+      []
+    end
+
+    def process
+      (@translation_calls + @children.flat_map(&:process)).flatten
+    end
+  end
+
+  class TranslationCall
+    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
+
+    def full_key
+      return nil if key.nil?
+      return nil unless key.is_a?(String)
+      return nil if relative_key? && !support_relative_keys?
+
+      parts = [scope]
+
+      if relative_key?
+        parts.concat(parent&.path || [])
+        parts << key
+
+        # TODO: Fallback to controller without action name
+      elsif key.start_with?('.')
+        parts << key[1..]
+      else
+        parts << key
+      end
+
+      parts.compact.join('.').gsub('..', '.')
+    end
+
+    private
+
+    def scope
+      return nil if @options.nil?
+      return nil unless @options['scope']
+
+      Array(@options['scope']).compact.map(&:to_s).join('.')
+    end
+
+    def occurrence(file_path)
+      local_node = @node
+
+      location = local_node.location
+
+      final_key = full_key
+      return nil if final_key.nil?
+
+      [
+        final_key,
+        ::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
+        )
+      ]
+    end
+
+    def occurrences_from_comments(file_path)
+      Array(@comment_translations).flat_map do |child_node|
+        child_node.with_context(
+          path: @path,
+          options: {
+            **@context_options,
+            comment_for_node: @node
+          }
+        ).occurrences(file_path)
+      end
+    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.support_relative_keys?
+    end
+  end
+
+  class ParsedModule < Root
+    def support_relative_keys?
+      false
+    end
+
+    def private_method
+      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 = []
+      @rails = rails
+
+      super(node: node, parent: parent)
+    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
+      return @children.flat_map(&:process) unless 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 { |call| call.with_parent(method) }
+          )
+        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)
+            fail(ArgumentError, "Cyclic call detected: #{call.name} -> #{method.name}")
+          end
+
+          other_method.translation_calls.each do |translation_call|
+            new_translation_calls.push(translation_call.with_parent(method))
+          end
+        end
+      end
+
+      @children.flat_map(&:process) + new_translation_calls
+    end
+
+    def private_methods!
+      @private_method = true
+    end
+
+    def support_relative_keys?
+      @rails && controller?
+    end
+
+    def path
+      (@parent&.path || []) + [path_name]
+    end
+
+    def controller?
+      @node.name.to_s.end_with?('Controller')
+    end
+
+    def path_name
+      path = @node.constant_path.full_name_parts.map { |s| s.to_s.underscore }
+      path.last.gsub!(/_controller\z/, '') 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_reader(:name)
+
+    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?
+      true
+    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
+  end
+end

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

@@ -0,0 +1,273 @@
+# 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
+# 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.
+
+module I18n::Tasks::Scanners::PrismScanners
+  class Visitor < Prism::Visitor # rubocop:disable Metrics/ClassLength
+    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/.freeze
+
+    attr_reader(:calls, :current_module, :current_class, :current_method, :root)
+
+    def initialize(comments: nil, rails: false)
+      @calls = []
+      @comment_translations_by_row = prepare_comments_by_line(comments)
+
+      @current_module = nil
+      @current_class = nil
+      @current_method = nil
+      @root = Root.new
+
+      @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 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)
+      )
+
+      super
+    ensure
+      @current_module = previous_module
+    end
+
+    def visit_class_node(node)
+      previous_class = @current_class
+
+      @current_class = parent.add_child(
+        ParsedClass.new(
+          node: node,
+          parent: parent,
+          rails: @rails
+        )
+      )
+
+      super
+    ensure
+      @current_class = previous_class
+    end
+
+    def visit_def_node(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
+        if @rails
+          return rails_call_node(node) do
+            super
+          end || parent.add_call(node)
+        else
+          parent.add_call(node)
+        end
+      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
+
+    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)
+      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)
+      end
+    end
+
+    # ---- Rails specific methods ----
+    # Returns true if the node was handled
+    def rails_call_node(node, &block)
+      case node.name
+      when :before_action
+        rails_handle_before_action(node, &block)
+        true
+      when :human_attribute_name
+        rails_handle_human_attribute_name(node)
+        true
+      when :human
+        return false if node.receiver.name != :model_name
+
+        rails_handle_model_name(node)
+        true
+      else
+        false
+      end
+    end
+
+    def rails_handle_before_action(node) # rubocop:disable Metrics/MethodLength
+      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)
+
+      yield
+    ensure
+      @current_before_action = nil
+    end
+
+    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'
+      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_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'
+        )
+      end
+
+      key = [
+        :activerecord,
+        :attributes,
+        node.receiver.name.to_s.underscore,
+        array_args.first
+      ].join('.')
+
+      parent.add_translation_call(
+        TranslationCall.new(
+          node: node,
+          key: key,
+          receiver: nil,
+          parent: parent,
+          options: {}
+        )
+      )
+    end
+  end
+end

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

@@ -3,10 +3,10 @@
 require 'i18n/tasks/scanners/file_scanner'
 require 'i18n/tasks/scanners/relative_keys'
 require 'i18n/tasks/scanners/ruby_ast_call_finder'
+require 'i18n/tasks/scanners/ruby_parser_factory'
 require 'i18n/tasks/scanners/ast_matchers/default_i18n_subject_matcher'
 require 'i18n/tasks/scanners/ast_matchers/message_receivers_matcher'
 require 'i18n/tasks/scanners/ast_matchers/rails_model_matcher'
-require 'parser/current'
 
 module I18n::Tasks::Scanners
   # Scan for I18n.translate calls using whitequark/parser
@@ -18,8 +18,8 @@ module I18n::Tasks::Scanners
 
     def initialize(**args)
       super(**args)
-      @parser = ::Parser::CurrentRuby.new
-      @magic_comment_parser = ::Parser::CurrentRuby.new
+      @parser = RubyParserFactory.create_parser
+      @magic_comment_parser = RubyParserFactory.create_parser
       @matchers = setup_matchers
     end
 

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

@@ -20,7 +20,7 @@ module I18n::Tasks::Scanners
       literal
     end
 
-    VALID_KEY_CHARS = %r{(?:[[:word:]]|[-.?!:;À-ž/])}.freeze
+    VALID_KEY_CHARS = %r{(?:[[:word:]]|[-.?!:;À-ž\\/]|(?<=[\p{L}\d])\s(?=[\p{L}\d]))}.freeze
     VALID_KEY_RE    = /^#{VALID_KEY_CHARS}+$/.freeze
 
     def valid_key?(key)

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# This module provides a factory class for creating a Ruby parser instance.
+# It temporarily disables verbose mode to suppress compatibility warnings
+# when loading the "parser/current" library.
+#
+# Example warning for the release of Ruby 3.4.1:
+#   warning: parser/current is loading parser/ruby34, which recognizes
+#   3.4.0-compliant syntax, but you are running 3.4.1.
+#   Please see https://github.com/whitequark/parser#compatibility-with-ruby-mri.
+#
+# By disabling verbose mode, these warnings are suppressed to provide a cleaner
+# output and avoid confusion. The verbose mode is restored after the parser
+# instance is created to maintain the original behavior.
+
+module I18n::Tasks::Scanners
+  class RubyParserFactory
+    def self.create_parser
+      prev = $VERBOSE
+      $VERBOSE = nil
+      require 'parser/current'
+      ::Parser::CurrentRuby.new
+    ensure
+      $VERBOSE = prev
+    end
+  end
+end

data/lib/i18n/tasks/translation.rb

@@ -3,6 +3,7 @@
 require 'i18n/tasks/translators/deepl_translator'
 require 'i18n/tasks/translators/google_translator'
 require 'i18n/tasks/translators/openai_translator'
+require 'i18n/tasks/translators/watsonx_translator'
 require 'i18n/tasks/translators/yandex_translator'
 
 module I18n::Tasks
@@ -11,7 +12,7 @@ module I18n::Tasks
     # @param [String] from locale
     # @param [:deepl, :openai, :google, :yandex] backend
     # @return [I18n::Tasks::Tree::Siblings] translated forest
-    def translate_forest(forest, from:, backend: :google)
+    def translate_forest(forest, from:, backend:)
       case backend
       when :deepl
         Translators::DeeplTranslator.new(self).translate_forest(forest, from)
@@ -19,6 +20,8 @@ module I18n::Tasks
         Translators::GoogleTranslator.new(self).translate_forest(forest, from)
       when :openai
         Translators::OpenAiTranslator.new(self).translate_forest(forest, from)
+      when :watsonx
+        Translators::WatsonxTranslator.new(self).translate_forest(forest, from)
       when :yandex
         Translators::YandexTranslator.new(self).translate_forest(forest, from)
       else

data/lib/i18n/tasks/translators/base_translator.rb

@@ -14,7 +14,11 @@ module I18n::Tasks
       # @return [I18n::Tasks::Tree::Siblings] translated forest
       def translate_forest(forest, from)
         forest.inject @i18n_tasks.empty_forest do |result, root|
-          translated = translate_pairs(root.key_values(root: true), to: root.key, from: from)
+          pairs = root.key_values(root: true)
+
+          @progress_bar = ProgressBar.create(total: pairs.flatten.size, format: '%a <%B> %e %c/%C (%p%%)')
+
+          translated = translate_pairs(pairs, to: root.key, from: from)
           result.merge! Data::Tree::Siblings.from_flat_pairs(translated)
         end
       end