i18n-tasks 1.1.1 → 1.2.0

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

@@ -4,7 +4,7 @@
 # Used in the PrismScanners::Visitor class.
 module I18n::Tasks::Scanners::PrismScanners
   class Root
-    attr_reader(:calls, :translation_calls, :children, :node, :parent, :rails, :file_path)
+    attr_reader(:calls, :translation_calls, :children, :node, :parent, :rails)
 
     def initialize(node: nil, parent: nil, file_path: nil, rails: false)
       @calls = []
@@ -16,6 +16,10 @@ module I18n::Tasks::Scanners::PrismScanners
       @file_path = file_path
     end
 
+    def file_path
+      @file_path || @parent&.file_path
+    end
+
     def add_child(node)
       @children << node
       node
@@ -30,15 +34,19 @@ module I18n::Tasks::Scanners::PrismScanners
     end
 
     def rails_view?
-      rails && file_path.present? && file_path.include?("app/views/")
-    end
+      return false unless rails && file_path.present?
 
-    def partial_view?
-      file_path.present? && File.basename(file_path).start_with?("_")
+      if file_path.include?("app/views/")
+        true
+      elsif file_path.include?("app/components/")
+        !file_path.end_with?(".rb")
+      else
+        false
+      end
     end
 
     def support_relative_keys?
-      rails_view? && !partial_view?
+      rails_view?
     end
 
     def support_candidate_keys?
@@ -47,8 +55,15 @@ module I18n::Tasks::Scanners::PrismScanners
 
     def path
       if rails_view?
-        folder_path = file_path.sub(%r{app/views/}, "").split("/")
+        folder_path = if file_path.include?("app/views/")
+          file_path.sub(%r{app/views/}, "").split("/")
+        else
+          file_path.sub(%r{app/components/}, "").split("/")
+        end
+
         name = folder_path.pop.split(".").first
+        # Remove leading underscores from partials
+        name = name[1..] if name.start_with?("_")
 
         [*folder_path, name]
       else
@@ -121,7 +136,7 @@ module I18n::Tasks::Scanners::PrismScanners
         # 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
+        rel_key = key[1..] # strip leading dot
 
         candidates = []
         parent_path_length = parent_path.length
@@ -134,15 +149,15 @@ module I18n::Tasks::Scanners::PrismScanners
         candidates.map { |c| c.gsub("..", ".") }
       elsif relative_key?
         # For relative keys in views, just append to the full path
-        [base_parts + parent.path + [key[1..]]].flatten.compact.join(".").gsub("..", ".") # rubocop:disable Performance/ChainArrayAllocation
+        [base_parts + parent.path + [key[1..]]].flatten.compact.join(".").gsub("..", ".")
       elsif key.start_with?(".")
-        [base_parts + [key[1..]]].flatten.compact.join(".").gsub("..", ".") # rubocop:disable Performance/ArraySemiInfiniteRangeSlice,Performance/ChainArrayAllocation
+        [base_parts + [key[1..]]].flatten.compact.join(".").gsub("..", ".")
       elsif @candidate_keys.present?
         ([key] + @candidate_keys).map do |c|
-          [base_parts + [c]].flatten.compact.join(".").gsub("..", ".") # rubocop:disable Performance/ChainArrayAllocation
+          [base_parts + [c]].flatten.compact.join(".").gsub("..", ".")
         end
       else
-        [base_parts + [key]].flatten.compact.join(".").gsub("..", ".") # rubocop:disable Performance/ChainArrayAllocation
+        [base_parts + [key]].flatten.compact.join(".").gsub("..", ".")
       end
     end
 
@@ -150,26 +165,37 @@ module I18n::Tasks::Scanners::PrismScanners
 
     def scope
       return nil if @options.nil?
-      return nil unless @options["scope"]
+      return nil unless @options.key?("scope")
+
+      scope_value = @options["scope"]
+      scope_array = Array(scope_value)
 
-      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) })
+      # ArgumentsVisitor returns a Prism::LocalVariableReadNode for local variables.
+      # Scope cannot be resolved if array is empty
+      if scope_value.is_a?(Prism::LocalVariableReadNode) ||
+          scope_array.empty? ||
+          !scope_array.all? { |s| s.is_a?(String) || s.is_a?(Symbol) }
+        fail(ScopeError, "Could not process scope")
+      end
 
-      Array(@options["scope"]).join(".")
+      scope_array.join(".")
     end
 
     def occurrence(file_path)
-      local_node = @node
-
-      location = local_node.location
+      location = @node.location
 
       final = full_key
       return nil if final.nil?
 
+      # A zero-length copy slices only the first line, not every line the node spans.
+      line = location.copy(length: 0).slice_lines.chomp
+
       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: line,
+        pos: location.start_character_offset,
+        # start_character_column counts the characters from the start of the file, twice.
+        line_pos: line.byteslice(0, location.start_column).length,
         line_num: location.start_line,
         raw_key: key,
         candidate_keys: Array(final)
@@ -304,7 +330,7 @@ module I18n::Tasks::Scanners::PrismScanners
     end
 
     def support_relative_keys?
-      controller? || mailer?
+      controller? || mailer? || view_component?
     end
 
     def support_candidate_keys?
@@ -323,6 +349,10 @@ module I18n::Tasks::Scanners::PrismScanners
       @rails && @node.name.to_s.end_with?("Mailer")
     end
 
+    def view_component?
+      @rails && file_path.present? && file_path.include?("app/components/")
+    end
+
     def path_name
       path = @node.constant_path.full_name_parts.map { |s| s.to_s.underscore }
       path.last.delete_suffix!("_controller") if controller?
@@ -345,7 +375,11 @@ module I18n::Tasks::Scanners::PrismScanners
     delegate(:support_candidate_keys?, to: :parent)
 
     def path
-      (@parent&.path || []) + [@node.name]
+      if @parent.respond_to?(:view_component?) && @parent.view_component?
+        @parent.path
+      else
+        (@parent&.path || []) + [@node.name]
+      end
     end
 
     def name

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

@@ -14,7 +14,7 @@ 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)
+    attr_reader(:calls, :current_module, :current_class, :current_method, :root, :processed_magic_comment_ids)
 
     def initialize(rails: false, file_path: nil)
       @calls = []
@@ -23,6 +23,7 @@ module I18n::Tasks::Scanners::PrismScanners
       @current_class = nil
       @current_method = nil
       @root = Root.new(file_path:, rails: rails)
+      @processed_magic_comment_ids = []
 
       @rails = rails
 
@@ -118,6 +119,26 @@ module I18n::Tasks::Scanners::PrismScanners
       super
     end
 
+    def visit_keyword_hash_node(node)
+      handle_comments(node)
+      super
+    end
+
+    def visit_statements_node(node)
+      handle_comments(node)
+      super
+    end
+
+    def visit_local_variable_write_node(node)
+      handle_comments(node)
+      super
+    end
+
+    def visit_symbol_node(node)
+      handle_comments(node)
+      super
+    end
+
     def process
       @root.process
     end
@@ -147,27 +168,38 @@ module I18n::Tasks::Scanners::PrismScanners
 
         next if match.nil?
 
+        @processed_magic_comment_ids << comment.object_id
+
         string =
           content.gsub(MAGIC_COMMENT_PREFIX, "").delete("#").strip
+        parse_result = Prism.parse(string)
+        next if parse_result.respond_to?(:errors) && parse_result.errors.any?
+
         visitor = Visitor.new
-        Prism
-          .parse(string)
-          .value
-          .accept(visitor)
+        parse_result.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))
+          parent.add_translation_call(comment_node.with_parent(parent).with_node(commented_node(node, comment)))
         end
       end
     end
 
+    # Prism 2.0 attaches a comment on its own line to the enclosing statements,
+    # Prism 1.x attached it to the next statement, or the previous one at the end.
+    def commented_node(node, comment)
+      return node unless node.type == :statements_node
+
+      comment_offset = comment.location.start_offset
+      node.body.find { |statement| statement.location.start_offset > comment_offset } || node.body.last || node
+    end
+
     def i18n_receiver?(receiver)
       case receiver.type
       when :constant_read_node
         receiver.name == :I18n
       when :constant_path_node
-        receiver.parent.nil? && receiver.child&.name == :I18n
+        receiver.parent.nil? && receiver.name == :I18n
       else
         false
       end
@@ -280,7 +312,7 @@ module I18n::Tasks::Scanners::PrismScanners
 
       # 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(".")
+        current_class.path.flatten.map!(&:underscore).join("/")
       elsif node.receiver&.receiver&.type == :constant_read_node
         node.receiver&.receiver&.name&.to_s&.underscore
       end
@@ -312,7 +344,14 @@ module I18n::Tasks::Scanners::PrismScanners
     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))
+      case node.receiver&.type
+      when :call_node
+        node.receiver.name == :class && node.receiver.receiver&.is_a?(Prism::SelfNode)
+      when nil
+        true
+      else
+        false
+      end
     end
 
     def rails_handle_human_attribute_name(node)
@@ -320,21 +359,36 @@ module I18n::Tasks::Scanners::PrismScanners
       # Arguments empty or cannot be processed, e.g. if it is a call
       return unless array_args.size == 1 && keywords.empty?
 
+      attribute_name = array_args.first
+      return unless attribute_name.is_a?(String)
+
+      # 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
+      # When attribute contains a dot, use slash separator between model and attribute
+      separator = attribute_name.include?(".") ? "/" : "."
+
       # 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(".")
+          current_class.path.flatten.map!(&:underscore).join("/")
+        ].join(".") + separator + attribute_name
       elsif node.receiver&.name.present?
+        # For namespaced models (Foo::Bar), Rails uses "/" as separator in i18n keys
+        # (e.g. activerecord.attributes.foo/bar.name). ConstantPathNode#full_name
+        # returns "Foo::Bar"; replace "::" with "/" to match that convention.
+        model_key = if node.receiver.is_a?(Prism::ConstantPathNode)
+          node.receiver.full_name.gsub(/^::/, "").gsub("::", "/").underscore
+        else
+          node.receiver.name.to_s.underscore
+        end
         [
           :activerecord,
           :attributes,
-          node.receiver.name.to_s.underscore,
-          array_args.first
-        ].join(".")
+          model_key
+        ].join(".") + separator + attribute_name
       else
         return
       end
@@ -343,7 +397,7 @@ module I18n::Tasks::Scanners::PrismScanners
         TranslationCall.new(
           node: node,
           key: key,
-          candidate_keys: Array([:attributes, array_args.first].join(".")),
+          candidate_keys: attribute_name.include?(".") ? [] : Array([:attributes, attribute_name].join(".")),
           receiver: nil,
           parent: parent,
           options: {}

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

@@ -15,13 +15,14 @@ module I18n
           return key unless key.start_with?(DOT)
           fail "roots argument is required" unless roots.present?
 
-          normalized_path = File.expand_path(path)
-          (root = path_root(normalized_path, roots)) ||
+          cwd = Dir.pwd
+          normalized_path = File.expand_path(path, cwd)
+          (root = path_root(normalized_path, roots, cwd)) ||
             fail(CommandError, "Cannot resolve relative key \"#{key}\".\n" \
                                "Set search.relative_roots in config/i18n-tasks.yml (currently #{roots.inspect})")
           normalized_path.sub!(root, "")
 
-          if (exclude_method_name_paths || []).map { |p| expand_path(p) }.include?(root)
+          if expand_paths(exclude_method_name_paths || [], cwd).include?(root)
             "#{prefix(normalized_path)}#{key}"
           else
             "#{prefix(normalized_path, calling_method: calling_method)}#{key}"
@@ -34,21 +35,30 @@ module I18n
 
         # Detect the appropriate relative path root
         # @param [String] path /full/path
-        # @param [Array<String>] roots array of full paths
+        # @param [Array<String>] roots relative or absolute paths
+        # @param [String] cwd the working directory to expand the roots against
         # @return [String] the closest ancestor root for path, with a trailing {File::SEPARATOR}.
-        def path_root(path, roots)
-          roots.map do |p|
-            expand_path(p)
-          end.sort.reverse_each.detect do |root|
+        def path_root(path, roots, cwd)
+          expand_paths(roots, cwd).sort.reverse_each.detect do |root|
             path.start_with?(root)
           end
         end
 
+        # Expanding a relative path reads the working directory, and this runs for each relative key:
+        # the working directory is read once by the caller, and the paths expanded against it are kept.
+        # @param [Array<String>] paths relative or absolute paths
+        # @param [String] cwd the working directory to expand them against
+        # @return [Array<String>] the paths expanded with {#expand_path}
+        def expand_paths(paths, cwd)
+          (@relative_keys_expanded_paths ||= {})[[cwd, paths]] ||= paths.map { |path| expand_path(path, cwd) }
+        end
+
         # Expand a path and add a trailing {File::SEPARATOR}
-        # @param [String] path relative path
+        # @param [String] path relative or absolute path
+        # @param [String] cwd the working directory to expand it against
         # @return [String] absolute path, with a trailing {File::SEPARATOR}.
-        def expand_path(path)
-          File.expand_path(path) + File::SEPARATOR
+        def expand_path(path, cwd)
+          File.expand_path(path, cwd) + File::SEPARATOR
         end
 
         # @param normalized_path [String] path/relative/to/a/root

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

@@ -9,6 +9,7 @@ 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 "i18n/tasks/scanners/prism_scanners/visitor"
+require "prism"
 
 module I18n::Tasks::Scanners
   # Scan for I18n.translate calls using whitequark/parser primarily and Prism if configured.
@@ -19,6 +20,11 @@ module I18n::Tasks::Scanners
     include ::I18n::Tasks::Logging
 
     MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/
+    # Only the magic comments need comments attached to nodes, and they all contain this.
+    MAGIC_COMMENT_MARKER = "i18n-tasks-"
+
+    # Prism 2.0 attaches comments to nodes while parsing, and removed ParseResult#attach_comments!
+    PRISM_PARSE_OPTIONS = Prism::ParseResult.method_defined?(:attach_comments!) ? {} : {attach_comments: true}
 
     protected
 
@@ -37,7 +43,7 @@ module I18n::Tasks::Scanners
 
     def ast_parser_parse_file(path)
       setup_ast_parser
-      ast, comments = path_to_ast_and_comments(path)
+      ast, comments = @parse_cache.fetch([self.class, path]) { path_to_ast_and_comments(path) }
 
       ast_to_occurences(ast) + comments_to_occurences(path, ast, comments)
     end
@@ -149,6 +155,7 @@ module I18n::Tasks::Scanners
           AstMatchers::MessageReceiversMatcher.new(
             receivers: [
               AST::Node.new(:const, [nil, :I18n]),
+              AST::Node.new(:const, [AST::Node.new(:cbase), :I18n]),
               nil
             ],
             message: message,
@@ -167,14 +174,18 @@ module I18n::Tasks::Scanners
     # Extract all occurrences of translate calls from the file at the given path.
     # @return [Array<[key, Results::KeyOccurrence]>] each occurrence found in the file
     def prism_parse_file(path)
-      # Need File.expand_path for JRuby
-      process_prism_results(path, Prism.parse_file(File.expand_path(path)))
+      source = File.read(path)
+      options = source.include?(MAGIC_COMMENT_MARKER) ? PRISM_PARSE_OPTIONS : {}
+      process_prism_results(path, Prism.parse(source, filepath: path, **options))
     end
 
     # This method handles only parsing to be able to test it properly.
     # Therefore it cannot handle the parsing itself.
     def process_prism_results(path, parse_results)
-      comments = parse_results.attach_comments!
+      if parse_results.respond_to?(:attach_comments!) && parse_results.source.source.include?(MAGIC_COMMENT_MARKER)
+        parse_results.attach_comments!
+      end
+      comments = parse_results.comments
       parsed = parse_results.value
 
       # Check for magic comment to skip prism parsing, fallback to Parser AST
@@ -187,7 +198,29 @@ module I18n::Tasks::Scanners
       parsed.accept(visitor)
 
       occurrences = []
-      visitor.process.each do |translation_call|
+      translation_calls = visitor.process
+
+      # Prism can leave some trailing comments unattached to AST nodes
+      # (for example, comments right before a method `end`).
+      comments.each do |comment|
+        next if visitor.processed_magic_comment_ids.include?(comment.object_id)
+
+        content = comment.respond_to?(:slice) ? comment.slice : comment.location.slice
+        next unless MAGIC_COMMENT_PREFIX.match?(content)
+
+        payload = content.sub(MAGIC_COMMENT_PREFIX, "").delete("#").strip
+        parsed_comment = Prism.parse(payload)
+        next if parsed_comment.respond_to?(:errors) && parsed_comment.errors.any?
+
+        comment_visitor = I18n::Tasks::Scanners::PrismScanners::Visitor.new
+        parsed_comment.value.accept(comment_visitor)
+
+        comment_visitor.process.each do |translation_call|
+          translation_calls << translation_call.with_node(comment)
+        end
+      end
+
+      translation_calls.each do |translation_call|
         result = translation_call.occurrences(path)
         next unless result
 

data/lib/i18n/tasks/split_key.rb

@@ -8,7 +8,8 @@ module I18n
       PARENTHESIS_PAIRS = %w({} [] () <>).freeze
       START_KEYS = PARENTHESIS_PAIRS.to_set { |pair| pair[0] }.freeze
       END_KEYS = PARENTHESIS_PAIRS.to_h { |pair| [pair[0], pair[1]] }.freeze
-      private_constant :PARENTHESIS_PAIRS, :START_KEYS, :END_KEYS
+      START_KEYS_PATTERN = Regexp.union(START_KEYS.to_a)
+      private_constant :PARENTHESIS_PAIRS, :START_KEYS, :END_KEYS, :START_KEYS_PATTERN
 
       # split a key by dots (.)
       # dots inside braces or parenthesis are not split on
@@ -18,16 +19,17 @@ module I18n
       # split_key 'a.b.c', 2 # => ['a', 'b.c']
       def split_key(key, max = Float::INFINITY)
         return [key] if max == 1
+        return split_on_dots(key, max) unless key.match?(START_KEYS_PATTERN)
 
         parts = []
         current_parenthesis_end_char = nil
-        part = ""
+        part = +""
         key.each_char.with_index do |char, index|
           if current_parenthesis_end_char
-            part += char
+            part << char
             current_parenthesis_end_char = nil if char == current_parenthesis_end_char
           elsif START_KEYS.include?(char)
-            part += char
+            part << char
             current_parenthesis_end_char = END_KEYS[char]
           elsif char == "."
             parts << part
@@ -36,9 +38,9 @@ module I18n
               parts << remaining unless remaining.empty?
               return parts
             end
-            part = ""
+            part = +""
           else
-            part += char
+            part << char
           end
         end
 
@@ -47,6 +49,14 @@ module I18n
         current_parenthesis_end_char ? parts.concat(part.split(".")) : parts << part
       end
 
+      # Most keys have no parenthesis: String#split gives the same result
+      # without allocating a new string for every character.
+      def split_on_dots(key, max)
+        parts = key.split(".", (max == Float::INFINITY) ? -1 : max)
+        parts.pop if parts.last == ""
+        parts
+      end
+
       def last_key_part(key)
         split_key(key).last
       end

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

@@ -21,21 +21,7 @@ module I18n::Tasks
 
           @progress_bar = ProgressBar.create(total: pairs.flatten.size, format: "%a <%B> %e %c/%C (%p%%)")
 
-          begin
-            translated = translate_pairs(pairs, to: root.key, from: from)
-          rescue => e
-            warn "Translation for locale #{root.key} failed: #{e.message}"
-            # If translate_pairs raised, try to salvage any partial translations
-            # by attempting to translate each slice individually and collecting successes.
-            translated = []
-            pairs.group_by { |k_v| @i18n_tasks.html_key? k_v[0], from }.each do |_is_html, list_slice|
-              translated.concat(fetch_translations(list_slice, to: root.key, from: from))
-            rescue => e2
-              warn "Partial translation failed for locale #{root.key}: #{e2.message} - leaving keys untranslated"
-              # leave the original list_slice untranslated
-              translated.concat(list_slice)
-            end
-          end
+          translated = translate_pairs(pairs, to: root.key, from: from)
 
           result.merge! Data::Tree::Siblings.from_flat_pairs(translated)
         end
@@ -53,13 +39,15 @@ module I18n::Tasks
         # copy reference keys as is, instead of translating
         reference_key_vals = list.select { |_k, v| v.is_a? Symbol } || []
         list -= reference_key_vals
-        result = list.group_by { |k_v| @i18n_tasks.html_key? k_v[0], opts[:from] }.map do |is_html, list_slice|
-          fetch_translations(list_slice, opts.merge(is_html ? options_for_html : options_for_plain))
-        rescue => e
-          warn "Translation slice failed: #{e.message} - leaving slice untranslated"
-          # Return the original untranslated slice so already completed translations are preserved
-          list_slice
-        end.reduce(:+) || []
+        result = list.group_by { |k_v| @i18n_tasks.html_key? k_v[0], opts[:from] }.flat_map do |is_html, list_slice|
+          slice_options = opts.merge(is_html ? options_for_html : options_for_plain)
+          translation_batches(list_slice, slice_options).flat_map do |batch|
+            fetch_translations(batch, slice_options)
+          rescue => e
+            warn "Translation batch failed: #{e.message} - skipping batch"
+            []
+          end
+        end
         result.concat(reference_key_vals)
         result.sort! { |a, b| key_pos[a[0]] <=> key_pos[b[0]] }
         result
@@ -69,7 +57,13 @@ module I18n::Tasks
       # @return [Array<[String, Object]>] translated list
       def fetch_translations(list, opts)
         options = options_for_translate_values(**opts)
-        from_values(list, translate_values(to_values(list, options), **options), options).tap do |result|
+        values = to_values(list, options)
+        translated_values = translate_values(values, **options)
+        if translated_values.size != values.size
+          fail CommandError, "Expected #{values.size} translations, got #{translated_values.size}"
+        end
+
+        from_values(list, translated_values, options).tap do |result|
           fail CommandError, no_results_error_message if result.blank?
         end
       end
@@ -188,6 +182,14 @@ module I18n::Tasks
       def options_for_plain
       end
 
+      # @param [Array<[String, Object]>] list
+      # @param [Hash] options
+      # @return [Array<Array<[String, Object]>>]
+      # @abstract
+      def translation_batches(list, _options)
+        [list]
+      end
+
       # @return [String]
       # @abstract
       def no_results_error_message

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

@@ -22,22 +22,21 @@ module I18n::Tasks::Translators
     protected
 
     def translate_values(list, from:, to:, **options)
-      results = []
-      list.each_slice(BATCH_SIZE) do |parts|
-        res = DeepL.translate(
-          parts,
-          to_deepl_source_locale(from),
-          to_deepl_target_locale(to),
-          options_with_glossary(options, from, to)
-        )
-        if res.is_a?(DeepL::Resources::Text)
-          results << res.text
-        else
-          results += res.map(&:text)
-        end
-
-        @progress_bar.progress += parts.size
+      return [] if list.empty?
+
+      res = DeepL.translate(
+        list,
+        to_deepl_source_locale(from),
+        to_deepl_target_locale(to),
+        options_with_glossary(options, from, to)
+      )
+      results = if res.is_a?(DeepL::Resources::Text)
+        [res.text]
+      else
+        res.map(&:text)
       end
+
+      @progress_bar.progress += list.size
       results
     end
 
@@ -55,6 +54,10 @@ module I18n::Tasks::Translators
       {preserve_formatting: true, tag_handling: "xml", html_escape: true}
     end
 
+    def translation_batches(list, _options)
+      list.each_slice(BATCH_SIZE).to_a
+    end
+
     # @param [String] value
     # @return [String] 'hello, %{name}' => 'hello, <i18n>%{name}</i18n>'
     def replace_interpolations(value)