i18n-tasks 0.9.37 → 1.0.13

data/lib/i18n/tasks/plural_keys.rb

@@ -52,15 +52,9 @@ module I18n::Tasks::PluralKeys
   end
 
   def plural_forms?(s)
-    return false if non_plural_other?(s)
-
     s.present? && s.all? { |node| node.leaf? && plural_suffix?(node.key) }
   end
 
-  def non_plural_other?(s)
-    s.size == 1 && s.first.leaf? && (!s.first.value.is_a?(String) || !s.first.value.include?('%{count}'))
-  end
-
   def plural_suffix?(key)
     PLURAL_KEY_SUFFIXES.include?(key)
   end

data/lib/i18n/tasks/references.rb

@@ -90,9 +90,9 @@ module I18n::Tasks
           on_leaves_merge: lambda do |node, other|
             if node.value != other.value
               log_warn(
-                'Conflicting references: '\
-            "#{node.full_key(root: false)} ⮕ #{node.value} in #{node.data[:locale]},"\
-            " but ⮕ #{other.value} in #{other.data[:locale]}"
+                'Conflicting references: ' \
+                "#{node.full_key(root: false)} ⮕ #{node.value} in #{node.data[:locale]}, " \
+                "but ⮕ #{other.value} in #{other.data[:locale]}"
               )
             end
           end

data/lib/i18n/tasks/reports/base.rb

@@ -36,8 +36,8 @@ module I18n::Tasks::Reports
 
     def used_title(keys_nodes, filter)
       used_n = keys_nodes.map { |_k, node| node.data[:occurrences].size }.reduce(:+).to_i
-      "#{keys_nodes.size} key#{'s' if keys_nodes.size != 1}#{" matching '#{filter}'" if filter}"\
-      "#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n.positive?}"
+      "#{keys_nodes.size} key#{'s' if keys_nodes.size != 1}#{" matching '#{filter}'" if filter}" \
+        "#{" (#{used_n} usage#{'s' if used_n != 1})" if used_n.positive?}"
     end
 
     # Sort keys by their attributes in order

data/lib/i18n/tasks/reports/terminal.rb

@@ -112,7 +112,7 @@ module I18n
           when :missing_plural
             leaf[:data][:missing_keys].join(', ')
           else
-            "#{Rainbow(leaf[:data][:missing_diff_locale]).cyan} "\
+            "#{Rainbow(leaf[:data][:missing_diff_locale]).cyan} " \
             "#{format_value(leaf[:value].is_a?(String) ? leaf[:value].strip : leaf[:value])}"
           end
         end
@@ -121,9 +121,9 @@ module I18n
           if data[:ref_info]
             from, to = data[:ref_info]
             resolved = key[0...to.length]
-            after    = key[to.length..-1]
+            after    = key[to.length..]
             "  #{Rainbow(from).yellow}#{Rainbow(after).cyan}\n" \
-            "#{Rainbow('⮕').yellow.bright} #{Rainbow(resolved).yellow.bright}"
+              "#{Rainbow('⮕').yellow.bright} #{Rainbow(resolved).yellow.bright}"
           else
             Rainbow(key).cyan
           end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module I18n::Tasks::Scanners::AstMatchers
+  class BaseMatcher
+    def initialize(scanner:)
+      @scanner = scanner
+    end
+
+    def convert_to_key_occurrences(send_node, _method_name, location: send_node.loc)
+      fail('Not implemented')
+    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) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+      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 the whole hash from a node of type `:hash`
+    #
+    # @param node [AST::Node] a node of type `:hash`.
+    # @return [Hash] the whole hash from the node
+    def extract_hash(node)
+      return {} if node.nil?
+
+      if node.type == :hash
+        node.children.each_with_object({}) do |pair, h|
+          key = pair.children[0].children[0].to_s
+          value = pair.children[1].children[0]
+          h[key] = value
+        end
+      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,91 @@
+# 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
+      if default_arg_node = extract_hash_pair(node, 'default')
+        default_arg = if default_arg_node.children[1]&.type == :hash
+                        extract_hash(default_arg_node.children[1])
+                      else
+                        extract_string(default_arg_node.children[1])
+                      end
+      end
+
+      [key, default_arg]
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/scanners/results/occurrence'
+
+module I18n::Tasks::Scanners::AstMatchers
+  class RailsModelMatcher < BaseMatcher
+    def convert_to_key_occurrences(send_node, _method_name, location: send_node.loc)
+      human_attribute_name_to_key_occurences(send_node: send_node, location: location) ||
+        model_name_human_to_key_occurences(send_node: send_node, location: location)
+    end
+
+    private
+
+    def human_attribute_name_to_key_occurences(send_node:, location:)
+      children = Array(send_node&.children)
+      receiver = children[0]
+      method_name = children[1]
+
+      return unless method_name == :human_attribute_name && receiver.type == :const
+
+      value = children[2]
+
+      model_name = underscore(receiver.to_a.last)
+      attribute = extract_string(value)
+      key = "activerecord.attributes.#{model_name}.#{attribute}"
+      [
+        key,
+        I18n::Tasks::Scanners::Results::Occurrence.from_range(
+          raw_key: key,
+          range: location.expression
+        )
+      ]
+    end
+
+    # User.model_name.human(count: 2)
+    # s(:send,
+    #   s(:send,
+    #     s(:const, nil, :User), :model_name), :human,
+    #   s(:hash,
+    #     s(:pair,
+    #       s(:sym, :count),
+    #       s(:int, 2))))
+    def model_name_human_to_key_occurences(send_node:, location:)
+      children = Array(send_node&.children)
+      return unless children[1] == :human
+
+      base_children = Array(children[0]&.children)
+      class_node = base_children[0]
+
+      return unless class_node&.type == :const && base_children[1] == :model_name
+
+      model_name = underscore(class_node.to_a.last)
+      key = "activerecord.models.#{model_name}"
+      [
+        key,
+        I18n::Tasks::Scanners::Results::Occurrence.from_range(
+          raw_key: key,
+          range: location.expression
+        )
+      ]
+    end
+
+    def underscore(value)
+      value = value.dup.to_s
+      value.gsub!(/(.)([A-Z])/, '\1_\2')
+      value.downcase!
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'ast'
+require 'set'
+require 'i18n/tasks/scanners/local_ruby_parser'
+
+module I18n::Tasks::Scanners
+  class ErbAstProcessor
+    include AST::Processor::Mixin
+    def initialize
+      super()
+      @ruby_parser = LocalRubyParser.new(ignore_blocks: true)
+      @comments = []
+    end
+
+    def process_and_extract_comments(ast)
+      result = process(ast)
+      [result, @comments]
+    end
+
+    def on_code(node)
+      parsed, comments = @ruby_parser.parse(
+        node.children[0],
+        location: node.location
+      )
+      @comments.concat(comments)
+
+      unless parsed.nil?
+        parsed = parsed.updated(
+          nil,
+          parsed.children.map { |child| node?(child) ? process(child) : child }
+        )
+        node = node.updated(:send, parsed)
+      end
+      node
+    end
+
+    # @param node [::Parser::AST::Node]
+    # @return [::Parser::AST::Node]
+    def handler_missing(node)
+      node = handle_comment(node)
+      return if node.nil?
+
+      node.updated(
+        nil,
+        node.children.map { |child| node?(child) ? process(child) : child }
+      )
+    end
+
+    private
+
+    # Convert ERB-comments to ::Parser::Source::Comment and skip processing node
+    #
+    # @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
+
+        # Do not continue parsing this node
+        comment = node.children[2]
+        @comments << ::Parser::Source::Comment.new(comment.location.expression)
+        return
+      end
+
+      node
+    end
+
+    def node?(node)
+      node.is_a?(::Parser::AST::Node)
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/scanners/ruby_ast_scanner'
+require 'i18n/tasks/scanners/erb_ast_processor'
+require 'better_html/errors'
+require 'better_html/parser'
+
+module I18n::Tasks::Scanners
+  # Scan for I18n.translate calls in ERB-file better-html and ASTs
+  class ErbAstScanner < RubyAstScanner
+    def initialize(**args)
+      super(**args)
+      @erb_ast_processor = ErbAstProcessor.new
+    end
+
+    private
+
+    # 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 = BetterHtml::Parser.new(make_buffer(path))
+      ast = convert_better_html(parser.ast)
+      @erb_ast_processor.process_and_extract_comments(ast)
+    end
+
+    # Convert BetterHtml nodes to Parser::AST::Node
+    #
+    # @param node BetterHtml::Parser::AST::Node
+    # @return Parser::AST::Node
+    def convert_better_html(node)
+      definition = Parser::Source::Map::Definition.new(
+        node.location.begin,
+        node.location.begin,
+        node.location.begin,
+        node.location.end
+      )
+      Parser::AST::Node.new(
+        node.type,
+        node.children.map { |child| child.is_a?(BetterHtml::AST::Node) ? convert_better_html(child) : child },
+        {
+          location: definition
+        }
+      )
+    end
+  end
+end

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/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!?)?/.freeze
+    TRANSLATE_CALL_RE = /(?<=^|[^\w'\-.]|[^\w'-]I18n\.|I18n\.)t(?:!|ranslate!?)?/.freeze
     IGNORE_LINES = {
       'coffee' => /^\s*#(?!\si18n-tasks-use)/,
       'erb' => /^\s*<%\s*#(?!\si18n-tasks-use)/,
@@ -66,7 +66,7 @@ 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
 

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

@@ -10,7 +10,7 @@ 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[:exclude_method_name_paths],
+                         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?
@@ -18,7 +18,7 @@ module I18n
           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, '')
 
           if (exclude_method_name_paths || []).map { |p| expand_path(p) }.include?(root)

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