i18n-tasks 1.0.5 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d600c7425116c27f5cadffdc23d6e29de6137f90cea588e1a046ca1ec5970f5
-  data.tar.gz: 91ea505ba06486d962e7be61eb52ca6af18bc8d481fdeb6a193f715b3c2f55a2
+  metadata.gz: 9d1d2fc604c929450bdf96a547513004630f57a1da7e368020b0313f4e4c67f4
+  data.tar.gz: 4b1a226b25f08c76d92998bc8cecd37de5e698f2f805da606804b8faa3fc0203
 SHA512:
-  metadata.gz: 0e74a51969f4a82f8fa479dc31cb9236cc9de5d6255fe99d6de9eb392fb85e8771f4b21cbaed35f8c114258ada6c88086fb6fae0f1e0d97d8eb1f2d317c4f834
-  data.tar.gz: 4a23c041ddef63f1b798f1455af637f77f369dcfb64e93f72c9592caf2105d2e9b15531679b30d7404746674596ee70078bba3525cbc2eacdce00d9d0ebc7054
+  metadata.gz: aeff02b2b63a8d64a37e80342b4dcf41c1a2c0379a8792b1064c6af431e18350c3130b890ee8bb83b4cc0cc6527b0721dabd2c7eb96ea420414b749d7c1b7a35
+  data.tar.gz: ce61d0886ca762588e101032f2d51207742f24f30d5c8d681594ea44ae08f508ac5f032f6bad2e27b117bf349794089753cd9669aa9e25de5d72831ac5db2d63

data/README.md

@@ -24,7 +24,7 @@ i18n-tasks can be used with any project using the ruby [i18n gem][i18n-gem] (def
 Add i18n-tasks to the Gemfile:
 
 ```ruby
-gem 'i18n-tasks', '~> 1.0.5'
+gem 'i18n-tasks', '~> 1.0.8'
 ```
 
 Copy the default [configuration file](#configuration):

data/lib/i18n/tasks/scanners/ast_matchers/base_matcher.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module I18n::Tasks::Scanners::AstMatchers
+  class BaseMatcher
+    def initialize(scanner:)
+      @scanner = scanner
+    end
+
+    protected
+
+    # 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.
+    #
+    # @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)
+      return if node.nil?
+
+      if %i[sym str int].include?(node.type)
+        node.children[0].to_s
+      elsif %i[true false].include?(node.type)
+        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 !@scanner.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
+      end
+    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
+    end
+
+    # Extract an array as a single string.
+    #
+    # @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)
+          extract_string child
+        else
+          # ignore dynamic argument in strict mode
+          return nil if @scanner.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}}"
+          end
+        end
+      end
+      if array_reject_blank
+        children_strings.reject! do |x|
+          # empty strings and nils in the scope argument are ignored by i18n
+          x == ''
+        end
+      end
+      children_strings.join(array_join_with)
+    end
+  end
+end

data/lib/i18n/tasks/scanners/ast_matchers/message_receivers_matcher.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/scanners/ast_matchers/base_matcher'
+require 'i18n/tasks/scanners/results/occurrence'
+
+module I18n::Tasks::Scanners::AstMatchers
+  class MessageReceiversMatcher < BaseMatcher
+    def initialize(scanner:, receivers:, message:)
+      super(scanner: scanner)
+      @receivers = Array(receivers)
+      @message = 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 convert_to_key_occurrences(send_node, method_name, location: send_node.loc)
+      return unless node_match?(send_node)
+
+      receiver = send_node.children[0]
+      first_arg_node = send_node.children[2]
+      second_arg_node = send_node.children[3]
+
+      key = extract_string(first_arg_node)
+      return if key.nil?
+
+      key, default_arg = process_options(node: second_arg_node, key: key)
+
+      return if key.nil?
+
+      [
+        full_key(receiver: receiver, key: key, location: location, calling_method: method_name),
+        I18n::Tasks::Scanners::Results::Occurrence.from_range(
+          raw_key: key,
+          range: location.expression,
+          default_arg: default_arg
+        )
+      ]
+    end
+
+    private
+
+    def node_match?(node)
+      receiver = node.children[0]
+      message = node.children[1]
+
+      @message == message && @receivers.any? { |r| r == receiver }
+    end
+
+    def full_key(receiver:, key:, location:, calling_method:)
+      if receiver.nil?
+        # Relative keys only work if called via `t()` but not `I18n.t()`:
+        @scanner.absolute_key(
+          key,
+          location.expression.source_buffer.name,
+          calling_method: calling_method
+        )
+      else
+        key
+      end
+    end
+
+    def process_options(node:, key:)
+      return [key, nil] if node&.type != :hash
+
+      scope_node = extract_hash_pair(node, 'scope')
+
+      if scope_node
+        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_node = extract_hash_pair(node, 'default')
+      default_arg = extract_string(default_arg_node.children[1]) if default_arg_node
+
+      [key, default_arg]
+    end
+  end
+end

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

@@ -38,7 +38,9 @@ module I18n::Tasks::Scanners
     # @param node [::Parser::AST::Node]
     # @return [::Parser::AST::Node]
     def handler_missing(node)
-      node = transform_misparsed_comment(node)
+      node = handle_comment(node)
+      return if node.nil?
+
       node.updated(
         nil,
         node.children.map { |child| node?(child) ? process(child) : child }
@@ -47,40 +49,22 @@ module I18n::Tasks::Scanners
 
     private
 
-    # Works around incorrect handling of comments of the form:
-    # <%# ... #>
-    # (no space between % and #)
-    #
-    # With a space the AST is:
-    #
-    #     s(:erb, nil, nil,
-    #       s(:code, " # this should not fail: ' "), nil)
+    # Convert ERB-comments to ::Parser::Source::Comment and skip processing node
     #
-    # Without a space the AST is:
-    #
-    #     s(:erb,
-    #       s(:indicator, "#"), nil,
-    #       s(:code, " this should not fail: ' "), nil)
-    # @param node [::Parser::AST::Node]
-    # @return [::Parser::AST::Node]
-    def transform_misparsed_comment(node)
-      return node unless node.type == :erb && node.children.size == 4 &&
-        node.children[0]&.type == :indicator && node.children[0].children[0] == "#" &&
-        node.children[1].nil? &&
-        node.children[2]&.type == :code &&
-        node.children[3].nil?
-      code_node = node.children[2]
+    # @param node Parser::AST::Node Potential comment node
+    # @return Parser::AST::Node or nil
+    def handle_comment(node)
+      if node.type == :erb && node.children.size == 4 &&
+         node.children[0]&.type == :indicator && node.children[0].children[0] == '#' &&
+         node.children[2]&.type == :code
 
-      # Prepend # to each line to make it a valid Ruby comment.
-      code = code_node.children[0].split("\n").map do |line|
-        next line if line =~ /^\s*#/
-        "##{line}"
-      end.join("\n")
+        # Do not continue parsing this node
+        comment = node.children[2]
+        @comments << ::Parser::Source::Comment.new(comment.location.expression)
+        return
+      end
 
-      node.updated(
-        nil,
-        [nil, nil, code_node.updated(nil, [code]), nil]
-      )
+      node
     end
 
     def node?(node)

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

@@ -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,57 +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/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+/.freeze
-    RECEIVER_MESSAGES = [nil, AST::Node.new(:const, [nil, :I18n])].product(%i[t t! translate translate!])
 
     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
@@ -48,141 +43,10 @@ module I18n::Tasks::Scanners
       @parser.parse_with_comments(make_buffer(path))
     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
-    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
-    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.
-    #
-    # @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)
-        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
-      end
-    end
-
-    # Extract an array as a single string.
-    #
-    # @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)
-          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}}"
-          end
-        end
-      end
-      if array_reject_blank
-        children_strings.reject! do |x|
-          # empty strings and nils in the scope argument are ignored by i18n
-          x == ''
-        end
-      end
-      children_strings.join(array_join_with)
-    end
-
     def keys_relative_to_calling_method?(path)
       /controllers|mailers/.match(path)
     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
-
     # Create an {Parser::Source::Buffer} with the given contents.
     # The contents are assigned a {Parser::Source::Buffer#raw_source}.
     #
@@ -211,12 +75,23 @@ module I18n::Tasks::Scanners
       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)
+        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
     end
 
@@ -225,10 +100,39 @@ module I18n::Tasks::Scanners
     # @param ast {Parser::Source::Comment}
     # @return [nil, [key, Occurrence]] full absolute key name and the occurrence.
     def ast_to_occurences(ast)
-      @call_finder.collect_calls(ast) do |send_node, method_name|
-        send_node_to_key_occurrence(send_node, method_name)
+      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
+
+      results
+    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
+        %i[t t! translate translate!].map do |message|
+          AstMatchers::MessageReceiversMatcher.new(
+            receivers: [
+              AST::Node.new(:const, [nil, :I18n]),
+              nil
+            ],
+            message: message,
+            scanner: self
+          )
+        end
       end
     end
   end
 end
-# rubocop:enable Metrics/AbcSize,Metrics/BlockNesting,Metrics/PerceivedComplexity

data/lib/i18n/tasks/version.rb

@@ -2,6 +2,6 @@
 
 module I18n
   module Tasks
-    VERSION = '1.0.5'
+    VERSION = '1.0.8'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-tasks
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.8
 platform: ruby
 authors:
 - glebm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-26 00:00:00.000000000 Z
+date: 2022-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -371,6 +371,8 @@ files:
 - lib/i18n/tasks/references.rb
 - lib/i18n/tasks/reports/base.rb
 - lib/i18n/tasks/reports/terminal.rb
+- lib/i18n/tasks/scanners/ast_matchers/base_matcher.rb
+- lib/i18n/tasks/scanners/ast_matchers/message_receivers_matcher.rb
 - lib/i18n/tasks/scanners/erb_ast_processor.rb
 - lib/i18n/tasks/scanners/erb_ast_scanner.rb
 - lib/i18n/tasks/scanners/file_scanner.rb