i18n-tasks 1.0.13 → 1.0.15

data/lib/i18n/tasks/data/router/isolating_router.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/key_pattern_matching'
+require 'i18n/tasks/data/tree/node'
+
+module I18n::Tasks
+  module Data::Router
+    # Route based on source file path
+    class IsolatingRouter
+      include ::I18n::Tasks::KeyPatternMatching
+
+      attr_reader :config_read_patterns, :base_locale
+
+      def initialize(_adapter, data_config)
+        @base_locale = data_config[:base_locale]
+        @config_read_patterns = Array.wrap(data_config[:read])
+      end
+
+      # Route keys to destinations
+      # @param forest [I18n::Tasks::Data::Tree::Siblings] forest roots are locales.
+      # @yieldparam [String] dest_path
+      # @yieldparam [I18n::Tasks::Data::Tree::Siblings] tree_slice
+      # @return [Hash] mapping of destination => [ [key, value], ... ]
+      def route(locale, forest, &block)
+        return to_enum(:route, locale, forest) unless block
+
+        locale = locale.to_s
+        out = {}
+
+        forest.keys do |key_namespaced_with_source_path, _node|
+          source_path, key = key_namespaced_with_source_path.match(/\A<([^>]*)>\.(.*)/).captures
+          target_path = alternate_path_for(source_path, locale)
+          next unless source_path && key && target_path
+
+          (out[target_path] ||= Set.new) << "#{locale}.#{key}"
+        end
+
+        out.each do |target_path, keys|
+          file_namespace_subtree = I18n::Tasks::Data::Tree::Siblings.new(
+            nodes: forest.get("#{locale}.<#{alternate_path_for(target_path, base_locale)}>")
+          )
+          file_namespace_subtree.set_root_key!(locale)
+
+          block.yield(
+            target_path,
+            file_namespace_subtree.select_keys { |key, _| keys.include?(key) }
+          )
+        end
+      end
+
+      def alternate_path_for(source_path, locale)
+        source_path = source_path.dup
+
+        config_read_patterns.each do |pattern|
+          regexp = Glob.new(format(pattern, locale: '(*)')).to_regexp
+          next unless source_path.match?(regexp)
+
+          source_path.match(regexp) do |match_data|
+            (1..match_data.size - 1).reverse_each do |capture_index|
+              capture_begin, capture_end = match_data.offset(capture_index)
+              source_path.slice!(Range.new(capture_begin, capture_end, true))
+              source_path.insert(capture_begin, locale.to_s)
+            end
+          end
+
+          return source_path
+        end
+
+        nil
+      end
+
+      # based on https://github.com/alexch/rerun/blob/36f2d237985b670752abbe4a7f6814893cdde96f/lib/rerun/glob.rb
+      class Glob
+        NO_LEADING_DOT = '(?=[^\.])'
+        START_OF_FILENAME = '(?:\A|\/)'
+        END_OF_STRING = '\z'
+
+        def initialize(pattern)
+          @pattern = pattern
+        end
+
+        def to_regexp_string # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+          chars = smoosh(@pattern.chars)
+
+          curlies = 0
+          escaping = false
+
+          string = chars.map do |char|
+            if escaping
+              escaping = false
+              next char
+            end
+
+            case char
+            when '**' then '(?:[^/]+/)*'
+            when '*' then '.*'
+            when '?' then '.'
+            when '.' then '\.'
+            when '{'
+              curlies += 1
+              '('
+            when '}'
+              if curlies.positive?
+                curlies -= 1
+                ')'
+              else
+                char
+              end
+            when ','
+              if curlies.positive?
+                '|'
+              else
+                char
+              end
+            when '\\'
+              escaping = true
+              '\\'
+            else char
+            end
+          end.join
+
+          START_OF_FILENAME + string + END_OF_STRING
+        end
+
+        def to_regexp
+          Regexp.new(to_regexp_string)
+        end
+
+        def smoosh(chars)
+          out = []
+          until chars.empty?
+            char = chars.shift
+            if char == '*' && chars.first == '*'
+              chars.shift
+              chars.shift if chars.first == '/'
+              out.push('**')
+            else
+              out.push(char)
+            end
+          end
+          out
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/data/tree/siblings.rb

@@ -36,7 +36,7 @@ module I18n::Tasks::Data::Tree
     # @param to_pattern [Regexp]
     # @param root [Boolean]
     # @return {old key => new key}
-    def mv_key!(from_pattern, to_pattern, root: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+    def mv_key!(from_pattern, to_pattern, root: false, retain: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       moved_forest = Siblings.new
       moved_nodes = []
       old_key_to_new_key = {}
@@ -69,7 +69,7 @@ module I18n::Tasks::Data::Tree
           node.value = new_target.to_sym
         end
       end
-      remove_nodes_and_emptied_ancestors! moved_nodes
+      remove_nodes_and_emptied_ancestors!(moved_nodes) unless retain
       merge! moved_forest
       old_key_to_new_key
     end

data/lib/i18n/tasks/interpolations.rb

@@ -5,7 +5,7 @@ module I18n::Tasks
     class << self
       attr_accessor :variable_regex
     end
-    @variable_regex = /%{[^}]+}/.freeze
+    @variable_regex = /(?<!%)%{[^}]+}/.freeze
 
     def inconsistent_interpolations(locales: nil, base_locale: nil) # rubocop:disable Metrics/AbcSize
       locales ||= self.locales

data/lib/i18n/tasks/key_pattern_matching.rb

@@ -31,10 +31,10 @@ module I18n::Tasks::KeyPatternMatching
 
   def key_pattern_re_body(key_pattern)
     key_pattern
-      .gsub(/\./, '\.')
-      .gsub(/\*:/, '[^.]+?')
-      .gsub(/\*/, '.*')
-      .gsub(/:/, '(?<=^|\.)[^.]+?(?=\.|$)')
+      .gsub('.', '\.')
+      .gsub('*:', '[^.]+?')
+      .gsub('*', '.*')
+      .gsub(':', '(?<=^|\.)[^.]+?(?=\.|$)')
       .gsub(/\{(.*?)}/) { "(#{Regexp.last_match(1).strip.gsub(/\s*,\s*/, '|')})" }
   end
 end

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

@@ -93,6 +93,12 @@ module I18n
           end
         end
 
+        def cp_results(results)
+          results.each do |(from, to)|
+            print_info "#{Rainbow(from).cyan} #{Rainbow('+').yellow.bright} #{Rainbow(to).green}"
+          end
+        end
+
         def check_normalized_results(non_normalized)
           if non_normalized.empty?
             print_success 'All data is normalized'

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/scanners/ast_matchers/base_matcher'
+require 'i18n/tasks/scanners/results/occurrence'
+
+module I18n::Tasks::Scanners::AstMatchers
+  class DefaultI18nSubjectMatcher < BaseMatcher
+    def convert_to_key_occurrences(send_node, method_name, location: send_node.loc)
+      children = Array(send_node&.children)
+      return unless children[1] == :default_i18n_subject
+
+      key = @scanner.absolute_key(
+        '.subject',
+        location.expression.source_buffer.name,
+        calling_method: method_name
+      )
+      [
+        key,
+        I18n::Tasks::Scanners::Results::Occurrence.from_range(
+          raw_key: key,
+          range: location.expression
+        )
+      ]
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module I18n::Tasks::Scanners::AstMatchers
       receiver = children[0]
       method_name = children[1]
 
-      return unless method_name == :human_attribute_name && receiver.type == :const
+      return unless method_name == :human_attribute_name && receiver&.type == :const
 
       value = children[2]
 

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

@@ -1,16 +1,16 @@
 # 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'
+require 'i18n/tasks/scanners/local_ruby_parser'
 
 module I18n::Tasks::Scanners
   # Scan for I18n.translate calls in ERB-file better-html and ASTs
   class ErbAstScanner < RubyAstScanner
+    DEFAULT_REGEXP = /<%(={1,2}|-|\#|%)?(.*?)([-=])?%>/m.freeze
+
     def initialize(**args)
       super(**args)
-      @erb_ast_processor = ErbAstProcessor.new
+      @ruby_parser = LocalRubyParser.new(ignore_blocks: true)
     end
 
     private
@@ -20,29 +20,59 @@ module I18n::Tasks::Scanners
     # @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)
+      comments = []
+      buffer = make_buffer(path)
+
+      children = []
+      buffer
+        .source
+        .scan(DEFAULT_REGEXP) do |indicator, code, tailch, _rspace|
+          match = Regexp.last_match
+          character = indicator ? indicator[0] : nil
+
+          start = match.begin(0) + 2 + (character&.size || 0)
+          stop = match.end(0) - 2 - (tailch&.size || 0)
+
+          case character
+          when '=', nil, '-'
+            parsed, parsed_comments = handle_code(buffer, code, start, stop)
+            comments.concat(parsed_comments)
+            children << parsed unless parsed.nil?
+          when '#', '#-'
+            comments << handle_comment(buffer, start, stop)
+          end
+        end
+
+      [root_node(children, buffer), comments]
     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
-        }
-      )
+    def handle_code(buffer, code, start, stop)
+      range = ::Parser::Source::Range.new(buffer, start, stop)
+      location =
+        Parser::Source::Map::Definition.new(
+          range.begin,
+          range.begin,
+          range.begin,
+          range.end
+        )
+      @ruby_parser.parse(code, location: location)
+    end
+
+    def handle_comment(buffer, start, stop)
+      range = ::Parser::Source::Range.new(buffer, start, stop)
+      ::Parser::Source::Comment.new(range)
+    end
+
+    def root_node(children, buffer)
+      range = ::Parser::Source::Range.new(buffer, 0, buffer.source.size)
+      location =
+        Parser::Source::Map::Definition.new(
+          range.begin,
+          range.begin,
+          range.begin,
+          range.end
+        )
+      ::Parser::AST::Node.new(:erb, children, location: location)
     end
   end
 end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'parser/current'
+require 'i18n/tasks/scanners/ruby_parser_factory'
 
 module I18n::Tasks::Scanners
   class LocalRubyParser
@@ -9,7 +9,7 @@ module I18n::Tasks::Scanners
     BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/.freeze
 
     def initialize(ignore_blocks: false)
-      @parser = ::Parser::CurrentRuby.new
+      @parser = RubyParserFactory.create_parser
       @ignore_blocks = ignore_blocks
     end
 

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

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'file_scanner'
+require_relative 'ruby_ast_scanner'
+
+module I18n::Tasks::Scanners
+  class PrismScanner < FileScanner
+    MAGIC_COMMENT_SKIP_PRISM = 'i18n-tasks-skip-prism'
+
+    def initialize(**args)
+      unless VISITOR
+        warn(
+          'Please make sure `prism` is available to use this feature. Fallback to Ruby AST Scanner.'
+        )
+      end
+      super
+
+      @fallback = RubyAstScanner.new(**args)
+    end
+
+    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)
+      return @fallback.send(:scan_file, path) if VISITOR.nil?
+
+      process_results(path, PARSER.parse_file(path))
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      raise(
+        ::I18n::Tasks::CommandError.new(
+          e,
+          "Error scanning #{path}: #{e.message}"
+        )
+      )
+    end
+
+    # Need to have method that can be overridden to be able to test it
+    def process_results(path, parse_results)
+      parsed = parse_results.value
+      comments = parse_results.comments
+
+      return @fallback.send(:scan_file, path) if skip_prism_comment?(comments)
+
+      rails = if config[:prism_visitor].blank?
+                true
+              else
+                config[:prism_visitor] != 'ruby'
+              end
+
+      visitor = VISITOR.new(comments: comments, rails: rails)
+      parsed.accept(visitor)
+
+      occurrences = []
+      visitor.process.each do |translation_call|
+        result = translation_call.occurrences(path)
+        occurrences << result if result
+      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
+
+    # This block handles adding a fallback if the `prism` gem is not available.
+    begin
+      require 'prism'
+      require_relative 'prism_scanners/visitor'
+      PARSER = Prism
+      VISITOR = I18n::Tasks::Scanners::PrismScanners::Visitor
+    rescue LoadError
+      PARSER = nil
+      VISITOR = nil
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'prism/visitor'
+
+# This class is used to parse the arguments to e.g. a Prism::CallNode and return the values we need
+# for turning them into translations and occurrences.
+# Used in the PrismScanners::Visitor class.
+module I18n::Tasks::Scanners::PrismScanners
+  class ArgumentsVisitor < Prism::Visitor
+    def visit_keyword_hash_node(node)
+      node.child_nodes.each_with_object({}) do |child, hash|
+        hash[visit(child.key)] = visit(child.value)
+        hash
+      end
+    end
+
+    def visit_symbol_node(node)
+      node.value
+    end
+
+    def visit_string_node(node)
+      node.content
+    end
+
+    def visit_array_node(node)
+      node.child_nodes.map { |child| visit(child) }
+    end
+
+    def visit_arguments_node(node)
+      node.child_nodes.map { |child| visit(child) }
+    end
+
+    def visit_integer_node(node)
+      node.value
+    end
+
+    def visit_lambda_node(node)
+      node
+    end
+  end
+end