i18n-tasks 0.9.33 → 1.0.12

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module I18n::Tasks::Scanners
+  class LocalRubyParser
+    # ignore_blocks feature inspired by shopify/better-html
+    # https://github.com/Shopify/better-html/blob/087943ffd2a5877fa977d71532010b0c91239519/lib/better_html/test_helper/ruby_node.rb#L24
+    BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/.freeze
+
+    def initialize(ignore_blocks: false)
+      @parser = ::Parser::CurrentRuby.new
+      @ignore_blocks = ignore_blocks
+    end
+
+    # Parse string and normalize location
+    def parse(source, location: nil)
+      buffer = ::Parser::Source::Buffer.new('(string)')
+      buffer.source = if @ignore_blocks
+                        source.sub(BLOCK_EXPR, '')
+                      else
+                        source
+                      end
+
+      @parser.reset
+      ast, comments = @parser.parse_with_comments(buffer)
+      ast = normalize_location(ast, location)
+      comments = comments.map { |comment| normalize_comment_location(comment, location) }
+      [ast, comments]
+    end
+
+    # Normalize location for all parsed nodes
+
+    # @param node {Parser::AST::Node} Node in parsed code
+    # @param location {Parser::Source::Map} Global location for the parsed string
+    # @return {Parser::AST::Node}
+    def normalize_location(node, location)
+      return node.map { |child| normalize_location(child, location) } if node.is_a?(Array)
+
+      return node unless node.is_a?(::Parser::AST::Node)
+
+      node.updated(
+        nil,
+        node.children.map { |child| normalize_location(child, location) },
+        { location: updated_location(location, node.location) }
+      )
+    end
+
+    # Calculate location relative to a global location
+    #
+    # @param global_location {Parser::Source::Map} Global location where the code was parsed
+    # @param local_location {Parser::Source::Map} Local location in the parsed string
+    # @return {Parser::Source::Map}
+    def updated_location(global_location, local_location)
+      return global_location if local_location.expression.nil?
+
+      range = ::Parser::Source::Range.new(
+        global_location.expression.source_buffer,
+        global_location.expression.to_range.begin + local_location.expression.to_range.begin,
+        global_location.expression.to_range.begin + local_location.expression.to_range.end
+      )
+
+      ::Parser::Source::Map::Definition.new(
+        range.begin,
+        range.begin,
+        range.begin,
+        range.end
+      )
+    end
+
+    # Normalize location for comment
+    #
+    # @param comment {Parser::Source::Comment} A comment with local location
+    # @param location {Parser::Source::Map} Global location for the parsed string
+    # @return {Parser::Source::Comment}
+    def normalize_comment_location(comment, location)
+      range = ::Parser::Source::Range.new(
+        location.expression.source_buffer,
+        location.expression.to_range.begin + comment.location.expression.to_range.begin,
+        location.expression.to_range.begin + comment.location.expression.to_range.end
+      )
+      ::Parser::Source::Comment.new(range)
+    end
+  end
+end

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

@@ -15,11 +15,11 @@ module I18n
           line_begin = contents.rindex(/^/, position - 1)
           line_end   = contents.index(/.(?=\r?\n|$)/, position)
           Results::Occurrence.new(
-            path:     path,
-            pos:      position,
+            path: path,
+            pos: position,
             line_num: contents[0..position].count("\n") + 1,
             line_pos: position - line_begin + 1,
-            line:     contents[line_begin..line_end],
+            line: contents[line_begin..line_end],
             raw_key: raw_key
           )
         end

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

@@ -35,7 +35,7 @@ module I18n::Tasks::Scanners
         result = []
         text.scan(pattern) do |_|
           match    = Regexp.last_match
-          matches  = Hash[match.names.map(&:to_sym).zip(match.captures)]
+          matches  = match.names.map(&:to_sym).zip(match.captures).to_h
           if matches.key?(:key)
             matches[:key] = strip_literal(matches[:key])
             next unless valid_key?(matches[:key])

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

@@ -12,7 +12,7 @@ module I18n::Tasks::Scanners
     include OccurrenceFromPosition
     include RubyKeyLiterals
 
-    TRANSLATE_CALL_RE = /(?<=^|[^\w'\-.]|[^\w'\-]I18n\.|I18n\.)t(?:!|ranslate!?)?/
+    TRANSLATE_CALL_RE = /(?<=^|[^\w'\-.]|[^\w'\-]I18n\.|I18n\.)t(?:!|ranslate!?)?/.freeze
     IGNORE_LINES = {
       'coffee' => /^\s*#(?!\si18n-tasks-use)/,
       'erb' => /^\s*<%\s*#(?!\si18n-tasks-use)/,
@@ -43,10 +43,13 @@ module I18n::Tasks::Scanners
         src_pos = Regexp.last_match.offset(0).first
         location = occurrence_from_position(path, text, src_pos, raw_key: strip_literal(match[0]))
         next if exclude_line?(location.line, path)
+
         key = match_to_key(match, path, location)
         next unless key
+
         key += ':' if key.end_with?('.')
         next unless valid_key?(key)
+
         keys << [key, location]
       end
       keys
@@ -63,11 +66,11 @@ module I18n::Tasks::Scanners
     end
 
     def exclude_line?(line, path)
-      re = @ignore_lines_res[File.extname(path)[1..-1]]
+      re = @ignore_lines_res[File.extname(path)[1..]]
       re && re =~ line
     end
 
-    VALID_KEY_RE_DYNAMIC = /^(#{VALID_KEY_CHARS}|[:\#{@}\[\]])+$/
+    VALID_KEY_RE_DYNAMIC = /^(#{VALID_KEY_CHARS}|[:\#{@}\[\]])+$/.freeze
 
     def valid_key?(key)
       if @config[:strict]
@@ -84,7 +87,7 @@ module I18n::Tasks::Scanners
     def closest_method(occurrence)
       method = File.readlines(occurrence.path, encoding: 'UTF-8')
                    .first(occurrence.line_num - 1).reverse_each.find { |x| x =~ /\bdef\b/ }
-      method && method.strip.sub(/^def\s*/, '').sub(/[\(\s;].*$/, '')
+      method && method.strip.sub(/^def\s*/, '').sub(/[(\s;].*$/, '')
     end
 
     # This method only exists for backwards compatibility with monkey-patches and plugins
@@ -93,7 +96,7 @@ module I18n::Tasks::Scanners
     def default_pattern
       # capture only the first argument
       /
-      #{translate_call_re} [\( ] \s* (?# fn call begin )
+      #{translate_call_re} [( ] \s* (?# fn call begin )
       (#{first_argument_re})         (?# capture the first argument)
       /x
     end

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

@@ -26,6 +26,7 @@ module I18n::Tasks::Scanners
       if scope
         scope_parts = extract_literal_or_array_of_literals(scope)
         return nil if scope_parts.nil? || scope_parts.empty?
+
         "#{scope_parts.join('.')}.#{key}"
       else
         key unless match[0] =~ /\A\w/
@@ -61,7 +62,7 @@ module I18n::Tasks::Scanners
 
     # extract literal or array of literals
     # returns nil on any other input
-    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/MethodLength,Metrics/PerceivedComplexity
     def extract_literal_or_array_of_literals(s)
       literals = []
       braces_stack = []
@@ -78,6 +79,7 @@ module I18n::Tasks::Scanners
       s.each_char.with_index do |c, i|
         if c == '['
           return nil unless braces_stack.empty?
+
           braces_stack.push(i)
         elsif c == ']'
           break
@@ -93,6 +95,6 @@ module I18n::Tasks::Scanners
       consume_literal.call unless acc.empty?
       literals
     end
-    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/MethodLength,Metrics/PerceivedComplexity
   end
 end

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

@@ -9,15 +9,23 @@ module I18n
         # @param roots [Array<String>] paths to relative roots
         # @param calling_method [#call, Symbol, String, false, nil]
         # @return [String] absolute version of the key
-        def absolute_key(key, path, roots: config[:relative_roots], calling_method: nil)
+        def absolute_key(key, path, roots: config[:relative_roots],
+                         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?
+
           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})")
+                               "Set search.relative_roots in config/i18n-tasks.yml (currently #{roots.inspect})")
           normalized_path.sub!(root, '')
-          "#{prefix(normalized_path, calling_method: calling_method)}#{key}"
+
+          if (exclude_method_name_paths || []).map { |p| expand_path(p) }.include?(root)
+            "#{prefix(normalized_path)}#{key}"
+          else
+            "#{prefix(normalized_path, calling_method: calling_method)}#{key}"
+          end
         end
 
         private
@@ -30,12 +38,19 @@ module I18n
         # @return [String] the closest ancestor root for path, with a trailing {File::SEPARATOR}.
         def path_root(path, roots)
           roots.map do |p|
-            File.expand_path(p) + File::SEPARATOR
+            expand_path(p)
           end.sort.reverse_each.detect do |root|
             path.start_with?(root)
           end
         end
 
+        # Expand a path and add a trailing {File::SEPARATOR}
+        # @param [String] path relative path
+        # @return [String] absolute path, with a trailing {File::SEPARATOR}.
+        def expand_path(path)
+          File.expand_path(path) + File::SEPARATOR
+        end
+
         # @param normalized_path [String] path/relative/to/a/root
         # @param calling_method [#call, Symbol, String, false, nil]
         def prefix(normalized_path, calling_method: nil)

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

@@ -48,7 +48,7 @@ module I18n::Tasks
         # rubocop:enable Metrics/ParameterLists
 
         def inspect
-          "Occurrence(#{@path}:#{@line_num}:#{@line_pos}:#{@pos}:#{@raw_key}:#{@default_arg})"
+          "Occurrence(#{@path}:#{@line_num}, line_pos: #{@line_pos}, pos: #{@pos}, raw_key: #{@raw_key}, default_arg: #{@default_arg}, line: #{@line})" # rubocop:disable Layout/LineLength
         end
 
         def ==(other)
@@ -63,6 +63,22 @@ module I18n::Tasks
         def hash
           [@path, @pos, @line_num, @line_pos, @line, @default_arg].hash
         end
+
+        # @param raw_key [String]
+        # @param range [Parser::Source::Range]
+        # @param default_arg [String, nil]
+        # @return [Results::Occurrence]
+        def self.from_range(raw_key:, range:, default_arg: nil)
+          Occurrence.new(
+            path: range.source_buffer.name,
+            pos: range.begin_pos,
+            line_num: range.line,
+            line_pos: range.column,
+            line: range.source_line,
+            raw_key: raw_key,
+            default_arg: default_arg
+          )
+        end
       end
     end
   end

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

@@ -1,56 +1,31 @@
 # frozen_string_literal: true
 
 require 'ast'
-require 'set'
+
 module I18n::Tasks::Scanners
   class RubyAstCallFinder
     include AST::Processor::Mixin
 
-    # @param receiver_messages [Set<Pair<[nil, AST::Node>, Symbol>>] The receiver-message pairs to look for.
-    def initialize(receiver_messages:)
-      super()
-      @message_receivers = receiver_messages.each_with_object({}) do |(receiver, message), t|
-        (t[message] ||= []) << receiver
-      end
-    end
-
     # @param root_node [Parser::AST:Node]
-    # @yieldparam send_node [Parser::AST:Node]
-    # @yieldparam method_name [nil, String] the surrounding method's name.
-    def find_calls(root_node, &block)
-      @callback = block
-      process root_node
-    ensure
-      @callback = nil
-    end
-
-    # @param root_node (see #find_calls)
-    # @yieldparam (see #find_calls)
-    # @return [Array<block return values excluding nils>]
+    # @return [Pair<Parser::AST::Node, method_name as string>] for all nodes with :send type
     def collect_calls(root_node)
-      results = []
-      find_calls root_node do |send_node, method_name|
-        result = yield send_node, method_name
-        results << result if result
-      end
-      results
+      @results = []
+      process(root_node)
+      @results
     end
 
     def on_def(node)
       @method_name = node.children[0]
-      handler_missing node
+      handler_missing(node)
     ensure
       @method_name = nil
     end
 
     def on_send(send_node)
-      receiver = send_node.children[0]
-      message  = send_node.children[1]
-      valid_receivers = @message_receivers[message]
-      # use `any?` because `include?` checks type equality, but the receiver is a Parser::AST::Node != AST::Node.
-      @callback.call(send_node, @method_name) if valid_receivers&.any? { |r| r == receiver }
+      @results << [send_node, @method_name]
+
       # always invoke handler_missing to get nested translations in children
-      handler_missing send_node
+      handler_missing(send_node)
       nil
     end
 

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

@@ -3,27 +3,22 @@
 require 'i18n/tasks/scanners/file_scanner'
 require 'i18n/tasks/scanners/relative_keys'
 require 'i18n/tasks/scanners/ruby_ast_call_finder'
+require 'i18n/tasks/scanners/ast_matchers/message_receivers_matcher'
 require 'parser/current'
 
-# rubocop:disable Metrics/AbcSize,Metrics/BlockNesting,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-# TODO: make this class more readable.
-
 module I18n::Tasks::Scanners
   # Scan for I18n.translate calls using whitequark/parser
-  class RubyAstScanner < FileScanner # rubocop:disable Metrics/ClassLength
+  class RubyAstScanner < FileScanner
     include RelativeKeys
     include AST::Sexp
 
-    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/
-    RECEIVER_MESSAGES = [nil, AST::Node.new(:const, [nil, :I18n])].product(%i[t t! translate translate!])
+    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/.freeze
 
     def initialize(**args)
       super(**args)
       @parser = ::Parser::CurrentRuby.new
       @magic_comment_parser = ::Parser::CurrentRuby.new
-      @call_finder = RubyAstCallFinder.new(
-        receiver_messages: config[:receiver_messages] || RECEIVER_MESSAGES
-      )
+      @matchers = setup_matchers
     end
 
     protected
@@ -32,175 +27,117 @@ module I18n::Tasks::Scanners
     #
     # @return [Array<[key, Results::KeyOccurrence]>] each occurrence found in the file
     def scan_file(path)
-      @parser.reset
-      ast, comments = @parser.parse_with_comments(make_buffer(path))
-
-      results = @call_finder.collect_calls ast do |send_node, method_name|
-        send_node_to_key_occurrence(send_node, method_name)
-      end
+      ast, comments = path_to_ast_and_comments(path)
 
-      magic_comments  = comments.select { |comment| comment.text =~ MAGIC_COMMENT_PREFIX }
-      comment_to_node = Parser::Source::Comment.associate_locations(ast, magic_comments).tap do |h|
-        # transform_values is only available in ActiveSupport 4.2+
-        h.each { |k, v| h[k] = v.first }
-      end.invert
-      results + (magic_comments.flat_map do |comment|
-        @parser.reset
-        associated_node = comment_to_node[comment]
-        @call_finder.collect_calls(
-          @parser.parse(make_buffer(path, comment.text.sub(MAGIC_COMMENT_PREFIX, '').split(/\s+(?=t)/).join('; ')))
-        ) do |send_node, _method_name|
-          # method_name is not available at this stage
-          send_node_to_key_occurrence(send_node, nil, location: associated_node || comment.location)
-        end
-      end)
+      ast_to_occurences(ast) + comments_to_occurences(path, ast, comments)
     rescue Exception => e # rubocop:disable Lint/RescueException
       raise ::I18n::Tasks::CommandError.new(e, "Error scanning #{path}: #{e.message}")
     end
 
-    # @param send_node [Parser::AST::Node]
-    # @param method_name [Symbol, nil]
-    # @param location [Parser::Source::Map]
-    # @return [nil, [key, Occurrence]] full absolute key name and the occurrence.
-    def send_node_to_key_occurrence(send_node, method_name, location: send_node.loc)
-      if (first_arg_node = send_node.children[2]) &&
-         (key = extract_string(first_arg_node))
-        if (second_arg_node = send_node.children[3]) &&
-           second_arg_node.type == :hash
-          if (scope_node = extract_hash_pair(second_arg_node, 'scope'))
-            scope = extract_string(scope_node.children[1],
-                                   array_join_with: '.', array_flatten: true, array_reject_blank: true)
-            return nil if scope.nil? && scope_node.type != :nil
-            key = [scope, key].join('.') unless scope == ''
-          end
-          default_arg = if (default_arg_node = extract_hash_pair(second_arg_node, 'default'))
-                          extract_string(default_arg_node.children[1])
-                        end
-        end
-        full_key = if send_node.children[0].nil?
-                     # Relative keys only work if called via `t()` but not `I18n.t()`:
-                     absolute_key(key, location.expression.source_buffer.name, calling_method: method_name)
-                   else
-                     key
-                   end
-        [full_key, range_to_occurrence(key, location.expression, default_arg: default_arg)]
-      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
 
-    # Extract a hash pair with a given literal key.
-    #
-    # @param node [AST::Node] a node of type `:hash`.
-    # @param key [String] node key as a string (indifferent symbol-string matching).
-    # @return [AST::Node, nil] a node of type `:pair` or nil.
-    def extract_hash_pair(node, key)
-      node.children.detect do |child|
-        next unless child.type == :pair
-        key_node = child.children[0]
-        %i[sym str].include?(key_node.type) && key_node.children[0].to_s == key
-      end
+    def keys_relative_to_calling_method?(path)
+      /controllers|mailers/.match(path)
     end
 
-    # If the node type is of `%i(sym str int false true)`, return the value as a string.
-    # Otherwise, if `config[:strict]` is `false` and the type is of `%i(dstr dsym)`,
-    # return the source as if it were a string.
+    # Create an {Parser::Source::Buffer} with the given contents.
+    # The contents are assigned a {Parser::Source::Buffer#raw_source}.
     #
-    # @param node [Parser::AST::Node]
-    # @param array_join_with [String, nil] if set to a string, arrays will be processed and their elements joined.
-    # @param array_flatten [Boolean] if true, nested arrays are flattened,
-    #     otherwise their source is copied and surrounded by #{}. No effect unless `array_join_with` is set.
-    # @param array_reject_blank [Boolean] if true, empty strings and `nil`s are skipped.
-    #      No effect unless `array_join_with` is set.
-    # @return [String, nil] `nil` is returned only when a dynamic value is encountered in strict mode
-    #     or the node type is not supported.
-    def extract_string(node, array_join_with: nil, array_flatten: false, array_reject_blank: false)
-      if %i[sym str int].include?(node.type)
-        node.children[0].to_s
-      elsif %i[true false].include?(node.type) # rubocop:disable Lint/BooleanSymbol
-        node.type.to_s
-      elsif node.type == :nil
-        ''
-      elsif node.type == :array && array_join_with
-        extract_array_as_string(
-          node,
-          array_join_with:    array_join_with,
-          array_flatten:      array_flatten,
-          array_reject_blank: array_reject_blank
-        ).tap do |str|
-          # `nil` is returned when a dynamic value is encountered in strict mode. Propagate:
-          return nil if str.nil?
-        end
-      elsif !config[:strict] && %i[dsym dstr].include?(node.type)
-        node.children.map do |child|
-          if %i[sym str].include?(child.type)
-            child.children[0].to_s
-          else
-            child.loc.expression.source
-          end
-        end.join
+    # @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
 
-    # Extract an array as a single string.
+    # Convert an array of {Parser::Source::Comment} to occurrences.
     #
-    # @param array_join_with [String] joiner of the array elements.
-    # @param array_flatten [Boolean] if true, nested arrays are flattened,
-    #     otherwise their source is copied and surrounded by #{}.
-    # @param array_reject_blank [Boolean] if true, empty strings and `nil`s are skipped.
-    # @return [String, nil] `nil` is returned only when a dynamic value is encountered in strict mode.
-    def extract_array_as_string(node, array_join_with:, array_flatten: false, array_reject_blank: false)
-      children_strings = node.children.map do |child|
-        if %i[sym str int true false].include?(child.type) # rubocop:disable Lint/BooleanSymbol
-          extract_string child
-        else
-          # ignore dynamic argument in strict mode
-          return nil if config[:strict]
-          if %i[dsym dstr].include?(child.type) || (child.type == :array && array_flatten)
-            extract_string(child, array_join_with: array_join_with)
-          else
-            "\#{#{child.loc.expression.source}}"
+    # @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
+            )
+            results << result if result
           end
         end
+
+        results
       end
-      if array_reject_blank
-        children_strings.reject! do |x|
-          # empty strings and nils in the scope argument are ignored by i18n
-          x == ''
+    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)
+          results << result if result
         end
       end
-      children_strings.join(array_join_with)
-    end
 
-    def keys_relative_to_calling_method?(path)
-      /controllers|mailers/.match(path)
+      results
     end
 
-    # @param raw_key [String]
-    # @param range [Parser::Source::Range]
-    # @param default_arg [String, nil]
-    # @return [Results::Occurrence]
-    def range_to_occurrence(raw_key, range, default_arg: nil)
-      Results::Occurrence.new(
-        path:        range.source_buffer.name,
-        pos:         range.begin_pos,
-        line_num:    range.line,
-        line_pos:    range.column,
-        line:        range.source_line,
-        raw_key:     raw_key,
-        default_arg: default_arg
-      )
-    end
+    def setup_matchers
+      if config[:receiver_messages]
+        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
 
-    # 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
+        Array(config[:ast_matchers]).each do |class_name|
+          matchers << ActiveSupport::Inflector.constantize(class_name).new(scanner: self)
+        end
+
+        matchers
       end
     end
   end
 end
-# rubocop:enable Metrics/AbcSize,Metrics/BlockNesting,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity

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

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