i18n-tasks 1.0.14 → 1.1.0

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:]]|[-.?!:;À-ž/])}.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

@@ -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/scanners/ruby_scanner.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "i18n/tasks/logging"
+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 "i18n/tasks/scanners/prism_scanners/visitor"
+
+module I18n::Tasks::Scanners
+  # Scan for I18n.translate calls using whitequark/parser primarily and Prism if configured.
+  class RubyScanner < FileScanner
+    MAGIC_COMMENT_SKIP_PRISM = "i18n-tasks-skip-prism"
+    include RelativeKeys
+    include AST::Sexp
+    include ::I18n::Tasks::Logging
+
+    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/
+
+    protected
+
+    # 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 scan_file(path)
+      if config[:prism]
+        prism_parse_file(path)
+      else
+        ast_parser_parse_file(path)
+      end
+    rescue => e
+      raise ::I18n::Tasks::CommandError.new(e, "Error scanning #{path}: #{e.message}")
+    end
+
+    def ast_parser_parse_file(path)
+      setup_ast_parser
+      ast, comments = path_to_ast_and_comments(path)
+
+      ast_to_occurences(ast) + comments_to_occurences(path, ast, comments)
+    end
+
+    # Parse file on path and returns AST and comments.
+    #
+    # @param path Path to file to parse
+    # @return [{Parser::AST::Node}, [Parser::Source::Comment]]
+    def path_to_ast_and_comments(path)
+      @parser.reset
+      @parser.parse_with_comments(make_buffer(path))
+    end
+
+    # Create an {Parser::Source::Buffer} with the given contents.
+    # The contents are assigned a {Parser::Source::Buffer#raw_source}.
+    #
+    # @param path [String] Path to assign as the buffer name.
+    # @param contents [String]
+    # @return [Parser::Source::Buffer] file contents
+    def make_buffer(path, contents = read_file(path))
+      Parser::Source::Buffer.new(path).tap do |buffer|
+        buffer.raw_source = contents
+      end
+    end
+
+    # Convert an array of {Parser::Source::Comment} to occurrences.
+    #
+    # @param path Path to file
+    # @param ast Parser::AST::Node
+    # @param comments [Parser::Source::Comment]
+    # @return [nil, [key, Occurrence]] full absolute key name and the occurrence.
+    def comments_to_occurences(path, ast, comments)
+      magic_comments = comments.select { |comment| comment.text =~ MAGIC_COMMENT_PREFIX }
+      comment_to_node = Parser::Source::Comment.associate_locations(ast, magic_comments).tap do |h|
+        h.transform_values!(&:first)
+      end.invert
+
+      magic_comments.flat_map do |comment|
+        @parser.reset
+        associated_node = comment_to_node[comment]
+        ast = @parser.parse(make_buffer(path, comment.text.sub(MAGIC_COMMENT_PREFIX, "").split(/\s+(?=t)/).join("; ")))
+        calls = RubyAstCallFinder.new.collect_calls(ast)
+        results = []
+
+        # method_name is not available at this stage
+        calls.each do |(send_node, _method_name)|
+          @matchers.each do |matcher|
+            result = matcher.convert_to_key_occurrences(
+              send_node,
+              nil,
+              location: associated_node || comment.location
+            )
+            next unless result
+
+            if result.is_a?(Array) && result.first.is_a?(Array)
+              results.concat(result)
+            else
+              results << result
+            end
+          end
+        end
+
+        results
+      end
+    end
+
+    # Convert {Parser::AST::Node} to occurrences.
+    #
+    # @param ast {Parser::Source::Comment}
+    # @return [nil, [key, Occurrence]] full absolute key name and the occurrence.
+    def ast_to_occurences(ast)
+      calls = RubyAstCallFinder.new.collect_calls(ast)
+      results = []
+      calls.each do |send_node, method_name|
+        @matchers.each do |matcher|
+          result = matcher.convert_to_key_occurrences(send_node, method_name)
+          next unless result
+
+          if result.is_a?(Array) && result.first.is_a?(Array)
+            results.concat(result)
+          else
+            results << result
+          end
+        end
+      end
+
+      results
+    end
+
+    def setup_ast_parser
+      @parser ||= RubyParserFactory.create_parser
+      @magic_comment_parser ||= RubyParserFactory.create_parser
+      setup_ast_matchers
+    end
+
+    def setup_ast_matchers
+      return if defined?(@matchers)
+
+      if config[:receiver_messages]
+        @matchers = config[:receiver_messages].map do |receiver, message|
+          AstMatchers::MessageReceiversMatcher.new(
+            receivers: [receiver],
+            message: message,
+            scanner: self
+          )
+        end
+      else
+        @matchers = %i[t t! translate translate!].map do |message|
+          AstMatchers::MessageReceiversMatcher.new(
+            receivers: [
+              AST::Node.new(:const, [nil, :I18n]),
+              nil
+            ],
+            message: message,
+            scanner: self
+          )
+        end
+
+        Array(config[:ast_matchers]).each do |class_name|
+          @matchers << ActiveSupport::Inflector.constantize(class_name).new(scanner: self)
+        end
+      end
+    end
+
+    # ---------- Prism parser below ----------
+
+    # 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)
+      process_prism_results(path, Prism.parse_file(path))
+    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!
+      parsed = parse_results.value
+
+      # Check for magic comment to skip prism parsing, fallback to Parser AST
+      return ast_parser_parse_file(path) if skip_prism_comment?(comments)
+
+      visitor = I18n::Tasks::Scanners::PrismScanners::Visitor.new(
+        rails: config[:prism] != "ruby",
+        file_path: path
+      )
+      parsed.accept(visitor)
+
+      occurrences = []
+      visitor.process.each do |translation_call|
+        result = translation_call.occurrences(path)
+        next unless result
+
+        if result.is_a?(Array) && result.first.is_a?(Array)
+          occurrences.concat(result)
+        else
+          occurrences << result
+        end
+      end
+
+      occurrences
+    end
+
+    def skip_prism_comment?(comments)
+      comments.any? do |comment|
+        content =
+          comment.respond_to?(:slice) ? comment.slice : comment.location.slice
+        content.include?(MAGIC_COMMENT_SKIP_PRISM)
+      end
+    end
+  end
+
+  class RubyAstScanner < RubyScanner
+    def initialize(**args)
+      warn_deprecated("RubyAstScanner is deprecated, use RubyScanner instead")
+      super
+    end
+  end
+
+  class PrismScanner < RubyScanner
+    def initialize(**args)
+      warn_deprecated('PrismScanner is deprecated, use RubyScanner with prism: "rails" or prism: "ruby" instead')
+      super
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/scanners/results/key_occurrences'
+require "i18n/tasks/scanners/results/key_occurrences"
 
 module I18n::Tasks::Scanners
   # Describes the API of a scanner.
@@ -11,7 +11,7 @@ module I18n::Tasks::Scanners
     # @abstract
     # @return [Array<Results::KeyOccurrences>] the keys found by this scanner and their occurrences.
     def keys
-      fail 'Unimplemented'
+      fail "Unimplemented"
     end
   end
 end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/scanners/scanner'
+require "i18n/tasks/scanners/scanner"
 
 module I18n::Tasks::Scanners
   # Run multiple {Scanner Scanners} and merge their results.

data/lib/i18n/tasks/split_key.rb

@@ -21,7 +21,7 @@ module I18n
 
         parts = []
         current_parenthesis_end_char = nil
-        part = ''
+        part = ""
         key.each_char.with_index do |char, index|
           if current_parenthesis_end_char
             part += char
@@ -29,14 +29,14 @@ module I18n
           elsif START_KEYS.include?(char)
             part += char
             current_parenthesis_end_char = END_KEYS[char]
-          elsif char == '.'
+          elsif char == "."
             parts << part
             if parts.size + 1 == max
               remaining = key[(index + 1)..]
               parts << remaining unless remaining.empty?
               return parts
             end
-            part = ''
+            part = ""
           else
             part += char
           end
@@ -44,7 +44,7 @@ module I18n
 
         return parts if part.empty?
 
-        current_parenthesis_end_char ? parts.concat(part.split('.')) : parts << part
+        current_parenthesis_end_char ? parts.concat(part.split(".")) : parts << part
       end
 
       def last_key_part(key)

data/lib/i18n/tasks/stats.rb

@@ -6,15 +6,15 @@ module I18n::Tasks
       key_count = forest.leaves.count
       locale_count = forest.count
       if key_count.zero?
-        { key_count: 0 }
+        {key_count: 0}
       else
         {
-          locales: forest.map(&:key).join(', '),
+          locales: forest.map(&:key).join(", "),
           key_count: key_count,
           locale_count: locale_count,
           per_locale_avg: forest.inject(0) { |sum, f| sum + f.leaves.count } / locale_count,
           key_segments_avg: format(
-            '%.1f', forest.leaves.inject(0) { |sum, node| sum + node.walk_to_root.count - 1 } / key_count.to_f
+            "%.1f", forest.leaves.inject(0) { |sum, node| sum + node.walk_to_root.count - 1 } / key_count.to_f
           ),
           value_chars_avg: forest.leaves.inject(0) { |sum, node| sum + node.value.to_s.length } / key_count
         }

data/lib/i18n/tasks/translation.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'i18n/tasks/translators/deepl_translator'
-require 'i18n/tasks/translators/google_translator'
-require 'i18n/tasks/translators/openai_translator'
-require 'i18n/tasks/translators/yandex_translator'
+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
   module Translation
@@ -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

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require "i18n/tasks/data/language_names"
+
 module I18n::Tasks
   module Translators
     class BaseTranslator
       include ::I18n::Tasks::Logging
+
       # @param [I18n::Tasks::BaseTask] i18n_tasks
       def initialize(i18n_tasks)
         @i18n_tasks = i18n_tasks
@@ -14,7 +17,26 @@ 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%%)")
+
+          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
+
           result.merge! Data::Tree::Siblings.from_flat_pairs(translated)
         end
       end
@@ -33,6 +55,10 @@ module I18n::Tasks
         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.concat(reference_key_vals)
         result.sort! { |a, b| key_pos[a[0]] <=> key_pos[b[0]] }
@@ -104,8 +130,7 @@ module I18n::Tasks
         end
       end
 
-      INTERPOLATION_KEY_RE = /%\{[^}]+}/.freeze
-      UNTRANSLATABLE_STRING = 'X__'
+      INTERPOLATION_KEY_RE = /%\{[^}]+}/
 
       # @param [String] value
       # @return [String] 'hello, %{name}' => 'hello, <round-trippable string>'
@@ -113,7 +138,7 @@ module I18n::Tasks
         i = -1
         value.gsub INTERPOLATION_KEY_RE do
           i += 1
-          "#{UNTRANSLATABLE_STRING}#{i}"
+          "X__#{i}"
         end
       end
 
@@ -121,13 +146,13 @@ module I18n::Tasks
       # @param [String] translated
       # @return [String] 'hello, <round-trippable string>' => 'hello, %{name}'
       def restore_interpolations(untranslated, translated)
-        return translated if untranslated !~ INTERPOLATION_KEY_RE
+        return translated if !INTERPOLATION_KEY_RE.match?(untranslated)
 
         values = untranslated.scan(INTERPOLATION_KEY_RE)
-        translated.gsub(/#{Regexp.escape(UNTRANSLATABLE_STRING)}\d+/i) do |m|
-          values[m[UNTRANSLATABLE_STRING.length..].to_i]
+        translated.gsub(/X__(\d+)/) do |m|
+          values[$1.to_i]
         end
-      rescue StandardError => e
+      rescue => e
         raise_interpolation_error(untranslated, translated, e)
       end
 
@@ -144,24 +169,29 @@ module I18n::Tasks
       # @param [Hash] options
       # @return [Array<String>]
       # @abstract
-      def translate_values(list, **options); end
+      def translate_values(list, **options)
+      end
 
       # @param [Hash] options
       # @return [Hash]
       # @abstract
-      def options_for_translate_values(options); end
+      def options_for_translate_values(options)
+      end
 
       # @return [Hash]
       # @abstract
-      def options_for_html; end
+      def options_for_html
+      end
 
       # @return [Hash]
       # @abstract
-      def options_for_plain; end
+      def options_for_plain
+      end
 
       # @return [String]
       # @abstract
-      def no_results_error_message; end
+      def no_results_error_message
+      end
     end
   end
 end