i18n-youdao-tasks 0.9.37

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

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/reports/base'
+require 'terminal-table'
+module I18n
+  module Tasks
+    module Reports
+      class Terminal < Base # rubocop:disable Metrics/ClassLength
+        def missing_keys(forest = task.missing_keys)
+          forest = collapse_missing_tree! forest
+          if forest.present?
+            print_title missing_title(forest)
+            print_table headings: [Rainbow(I18n.t('i18n_tasks.common.locale')).cyan.bright,
+                                   Rainbow(I18n.t('i18n_tasks.common.key')).cyan.bright,
+                                   I18n.t('i18n_tasks.missing.details_title')] do |t|
+              t.rows = sort_by_attr!(forest_to_attr(forest)).map do |a|
+                [{ value: Rainbow(format_locale(a[:locale])).cyan, alignment: :center },
+                 format_key(a[:key], a[:data]),
+                 missing_key_info(a)]
+              end
+            end
+          else
+            print_success I18n.t('i18n_tasks.missing.none')
+          end
+        end
+
+        def inconsistent_interpolations(forest = task.inconsistent_interpolations)
+          if forest.present?
+            print_title inconsistent_interpolations_title(forest)
+            show_tree(forest)
+          else
+            print_success I18n.t('i18n_tasks.inconsistent_interpolations.none')
+          end
+        end
+
+        def used_keys(used_tree = task.used_tree)
+          # For the used tree we may have usage nodes that are not leaves as references.
+          keys_nodes = used_tree.nodes.select { |node| node.data[:occurrences].present? }.map do |node|
+            [node.full_key(root: false), node]
+          end
+          print_title used_title(keys_nodes, used_tree.first.root.data[:key_filter])
+          # Group multiple nodes
+          if keys_nodes.present?
+            keys_nodes.sort! { |a, b| a[0] <=> b[0] }.each do |key, node|
+              print_occurrences node, key
+            end
+          else
+            print_error I18n.t('i18n_tasks.usages.none')
+          end
+        end
+
+        def unused_keys(tree = task.unused_keys)
+          keys = tree.root_key_value_data(true)
+          if keys.present?
+            print_title unused_title(keys)
+            print_locale_key_value_data_table keys
+          else
+            print_success I18n.t('i18n_tasks.unused.none')
+          end
+        end
+
+        def eq_base_keys(tree = task.eq_base_keys)
+          keys = tree.root_key_value_data(true)
+          if keys.present?
+            print_title eq_base_title(keys)
+            print_locale_key_value_data_table keys
+          else
+            print_info Rainbow('No translations are the same as base value').cyan
+          end
+        end
+
+        def show_tree(tree)
+          print_locale_key_value_data_table tree.root_key_value_data(true)
+        end
+
+        def forest_stats(forest, stats = task.forest_stats(forest))
+          text  = if stats[:locale_count] == 1
+                    I18n.t('i18n_tasks.data_stats.text_single_locale', **stats)
+                  else
+                    I18n.t('i18n_tasks.data_stats.text', **stats)
+                  end
+          title = Rainbow(I18n.t('i18n_tasks.data_stats.title', **stats.slice(:locales))).bright
+          print_info "#{Rainbow(title).cyan} #{Rainbow(text).cyan}"
+        end
+
+        def mv_results(results)
+          results.each do |(from, to)|
+            if to
+              print_info "#{Rainbow(from).cyan} #{Rainbow('⮕').yellow.bright} #{Rainbow(to).cyan}"
+            else
+              print_info "#{Rainbow(from).red}#{Rainbow(' 🗑').red.bright}"
+            end
+          end
+        end
+
+        def check_normalized_results(non_normalized)
+          if non_normalized.empty?
+            print_success 'All data is normalized'
+            return
+          end
+          log_stderr Rainbow('The following data requires normalization:').yellow
+          puts non_normalized
+          log_stderr Rainbow('Run `i18n-tasks normalize` to fix').yellow
+        end
+
+        private
+
+        def missing_key_info(leaf)
+          case leaf[:type]
+          when :missing_used
+            first_occurrence leaf
+          when :missing_plural
+            leaf[:data][:missing_keys].join(', ')
+          else
+            "#{Rainbow(leaf[:data][:missing_diff_locale]).cyan} "\
+            "#{format_value(leaf[:value].is_a?(String) ? leaf[:value].strip : leaf[:value])}"
+          end
+        end
+
+        def format_key(key, data)
+          if data[:ref_info]
+            from, to = data[:ref_info]
+            resolved = key[0...to.length]
+            after    = key[to.length..-1]
+            "  #{Rainbow(from).yellow}#{Rainbow(after).cyan}\n" \
+            "#{Rainbow('⮕').yellow.bright} #{Rainbow(resolved).yellow.bright}"
+          else
+            Rainbow(key).cyan
+          end
+        end
+
+        def format_value(val)
+          val.is_a?(Symbol) ? "#{Rainbow('⮕ ').yellow.bright}#{Rainbow(val).yellow}" : val.to_s.strip
+        end
+
+        def format_reference_desc(node_data)
+          return nil unless node_data
+
+          case node_data[:ref_type]
+          when :reference_usage
+            Rainbow('(ref)').yellow.bright
+          when :reference_usage_resolved
+            Rainbow('(resolved ref)').yellow.bright
+          when :reference_usage_key
+            Rainbow('(ref key)').yellow.bright
+          end
+        end
+
+        def print_occurrences(node, full_key = node.full_key)
+          occurrences = node.data[:occurrences]
+          puts [Rainbow(full_key).bright,
+                format_reference_desc(node.data),
+                (Rainbow(occurrences.size).green if occurrences.size > 1)].compact.join ' '
+          occurrences.each do |occurrence|
+            puts "  #{key_occurrence full_key, occurrence}"
+          end
+        end
+
+        def print_locale_key_value_data_table(locale_key_value_datas)
+          if locale_key_value_datas.present?
+            print_table headings: [Rainbow(I18n.t('i18n_tasks.common.locale')).cyan.bright,
+                                   Rainbow(I18n.t('i18n_tasks.common.key')).cyan.bright,
+                                   I18n.t('i18n_tasks.common.value')] do |t|
+              t.rows = locale_key_value_datas.map do |(locale, k, v, data)|
+                [{ value: Rainbow(locale).cyan, alignment: :center }, format_key(k, data), format_value(v)]
+              end
+            end
+          else
+            puts 'ø'
+          end
+        end
+
+        def print_title(title)
+          log_stderr "#{Rainbow(title.strip).bright} #{Rainbow('|').faint} " \
+                     "#{"i18n-tasks v#{I18n::Tasks::VERSION}"}"
+        end
+
+        def print_success(message)
+          log_stderr Rainbow("✓ #{I18n.t('i18n_tasks.cmd.encourage').sample} #{message}").green.bright
+        end
+
+        def print_error(message)
+          log_stderr(Rainbow(message).red.bright)
+        end
+
+        def print_info(message)
+          log_stderr message
+        end
+
+        def indent(txt, n = 2)
+          txt.gsub(/^/, ' ' * n)
+        end
+
+        def print_table(opts, &block)
+          puts ::Terminal::Table.new(opts, &block)
+        end
+
+        def key_occurrence(full_key, occurrence)
+          location = Rainbow("#{occurrence.path}:#{occurrence.line_num}").green
+          source   = highlight_key(occurrence.raw_key || full_key, occurrence.line, occurrence.line_pos..-1).strip
+          "#{location} #{source}"
+        end
+
+        def first_occurrence(leaf)
+          # @type [I18n::Tasks::Scanners::KeyOccurrences]
+          occurrences = leaf[:data][:occurrences]
+          # @type [I18n::Tasks::Scanners::Occurrence]
+          first = occurrences.first
+          [
+            Rainbow("#{first.path}:#{first.line_num}").green,
+            ("(#{I18n.t 'i18n_tasks.common.n_more', count: occurrences.length - 1})" if occurrences.length > 1)
+          ].compact.join(' ')
+        end
+
+        def highlight_key(full_key, line, range = (0..-1))
+          line.dup.tap do |s|
+            s[range] = s[range].sub(full_key) do |m|
+              highlight_string m
+            end
+          end
+        end
+
+        module HighlightUnderline
+          def highlight_string(s)
+            Rainbow(s).underline
+          end
+        end
+
+        module HighlightOther
+          def highlight_string(s)
+            Rainbow(s).yellow
+          end
+        end
+
+        if Gem.win_platform?
+          include HighlightOther
+        else
+          include HighlightUnderline
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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
+      @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
+
+    def handler_missing(node)
+      node.updated(
+        nil,
+        node.children.map { |child| node?(child) ? process(child) : child }
+      )
+    end
+
+    private
+
+    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'
+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/file_scanner.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/scanners/scanner'
+
+module I18n::Tasks::Scanners
+  # A base class for a scanner that analyses files.
+  #
+  # @abstract The child must implement {#scan_file}.
+  # @since 0.9.0
+  class FileScanner < Scanner
+    attr_reader :config
+
+    def initialize(
+      config: {},
+      file_finder_provider: Files::CachingFileFinderProvider.new,
+      file_reader: Files::CachingFileReader.new
+    )
+      super()
+      @config      = config
+      @file_reader = file_reader
+      @file_finder = file_finder_provider.get(**config.slice(:paths, :only, :exclude))
+    end
+
+    # @return (see Scanner#keys)
+    def keys
+      (traverse_files do |path|
+        scan_file(path)
+      end.reduce(:+) || []).group_by(&:first).map do |key, keys_occurrences|
+        Results::KeyOccurrences.new(key: key, occurrences: keys_occurrences.map(&:second))
+      end
+    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)
+      fail 'Unimplemented'
+    end
+
+    # Read a file. Reads of the same path are cached.
+    #
+    # @param path [String]
+    # @return [String] file contents
+    def read_file(path)
+      @file_reader.read_file(path)
+    end
+
+    # Traverse the paths and yield the matching ones.
+    #
+    # @note This method is cached, it will only access the filesystem on the first invocation.
+    # @param (see FileFinder#traverse_files)
+    # @yieldparam (see FileFinder#traverse_files)
+    # @return (see FileFinder#traverse_files)
+    def traverse_files(&block)
+      @file_finder.traverse_files(&block)
+    end
+
+    # @note This method is cached, it will only access the filesystem on the first invocation.
+    # @return (see FileFinder#find_files)
+    def find_files
+      @file_finder.find_files
+    end
+  end
+end

data/lib/i18n/tasks/scanners/files/caching_file_finder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/concurrent/cached_value'
+require 'i18n/tasks/scanners/files/file_finder'
+
+module I18n::Tasks::Scanners::Files
+  # Finds the files in the specified search paths with support for exclusion / inclusion patterns.
+  # Wraps a {FileFinder} and caches the results.
+  #
+  # @note This class is thread-safe. All methods are cached.
+  # @since 0.9.0
+  class CachingFileFinder < FileFinder
+    # @param (see FileFinder#initialize)
+    def initialize(**args)
+      super
+      @cached_value = ::I18n::Tasks::Concurrent::CachedValue.new { uncached_find_files }
+    end
+
+    # Traverse the paths and yield the matching ones.
+    #
+    # @note This method is cached, it will only access the filesystem on the first invocation.
+    # @param (see FileFinder#traverse_files)
+    # @yieldparam (see FileFinder#traverse_files)
+    # @return (see FileFinder#traverse_files)
+
+    alias uncached_find_files find_files
+    private :uncached_find_files
+
+    # @note This method is cached, it will only access the filesystem on the first invocation.
+    # @return (see FileFinder#find_files)
+    def find_files
+      @cached_value.get
+    end
+  end
+end

data/lib/i18n/tasks/scanners/files/caching_file_finder_provider.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/concurrent/cache'
+require 'i18n/tasks/scanners/files/caching_file_finder'
+
+module I18n::Tasks::Scanners::Files
+  # Finds the files and provides their contents.
+  #
+  # @note This class is thread-safe. All methods are cached.
+  # @since 0.9.0
+  class CachingFileFinderProvider
+    # @param exclude [Array<String>]
+    def initialize(exclude: [])
+      @cache = ::I18n::Tasks::Concurrent::Cache.new
+      @defaults = { exclude: exclude }
+    end
+
+    # Initialize a {CachingFileFinder} or get one from cache based on the constructor arguments.
+    #
+    # @param (see FileFinder#initialize)
+    # @return [CachingFileFinder]
+    def get(**file_finder_args)
+      @cache.fetch(file_finder_args) do
+        args = file_finder_args.dup
+        args[:exclude] = @defaults[:exclude] + (args[:exclude] || [])
+        args[:exclude].uniq!
+        CachingFileFinder.new(**args)
+      end
+    end
+  end
+end

data/lib/i18n/tasks/scanners/files/caching_file_reader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks/concurrent/cache'
+require 'i18n/tasks/scanners/files/file_reader'
+
+module I18n::Tasks::Scanners::Files
+  # Reads the files in 'rb' mode and UTF-8 encoding.
+  # Wraps a {FileReader} and caches the results.
+  #
+  # @note This class is thread-safe. All methods are cached.
+  # @since 0.9.0
+  class CachingFileReader < FileReader
+    def initialize
+      super
+      @cache = ::I18n::Tasks::Concurrent::Cache.new
+    end
+
+    # Return the contents of the file at the given path.
+    # The file is read in the 'rb' mode and UTF-8 encoding.
+    #
+    # @param (see FileReader#read_file)
+    # @return (see FileReader#read_file)
+    # @note This method is cached, it will only access the filesystem on the first invocation.
+    def read_file(path)
+      @cache.fetch(File.expand_path(path)) { super }
+    end
+  end
+end

data/lib/i18n/tasks/scanners/files/file_finder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module I18n::Tasks::Scanners::Files
+  # Finds the files in the specified search paths with support for exclusion / inclusion patterns.
+  #
+  # @since 0.9.0
+  class FileFinder
+    include I18n::Tasks::Logging
+
+    # @param paths [Array<String>] {Find.find}-compatible paths to traverse,
+    #     absolute or relative to the working directory.
+    # @param only [Array<String>, nil] {File.fnmatch}-compatible patterns files to include.
+    #     Files not matching any of the inclusion patterns will be excluded.
+    # @param exclude [Arry<String>] {File.fnmatch}-compatible patterns of files to exclude.
+    #     Files matching any of the exclusion patterns will be excluded even if they match an inclusion pattern.
+    def initialize(paths: ['.'], only: nil, exclude: [])
+      fail 'paths argument is required' if paths.nil?
+
+      @paths   = paths
+      @include = only
+      @exclude = exclude || []
+    end
+
+    # Traverse the paths and yield the matching ones.
+    #
+    # @yield [path]
+    # @yieldparam path [String] the path of the found file.
+    # @return [Array<of block results>]
+    def traverse_files(&block)
+      find_files.map(&block)
+    end
+
+    # @return [Array<String>] found files
+    def find_files # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      results = []
+      paths = @paths.select { |p| File.exist?(p) }
+      log_warn "None of the search.paths exist #{@paths.inspect}" if paths.empty?
+      Find.find(*paths) do |path|
+        is_dir   = File.directory?(path)
+        hidden   = File.basename(path).start_with?('.') && !%w[. ./].include?(path)
+        not_incl = @include && !path_fnmatch_any?(path, @include)
+        excl     = path_fnmatch_any?(path, @exclude)
+        if is_dir || hidden || not_incl || excl
+          Find.prune if is_dir && (hidden || excl)
+        else
+          results << path
+        end
+      end
+      results
+    end
+
+    private
+
+    # @param path [String]
+    # @param globs [Array<String>]
+    # @return [Boolean]
+    def path_fnmatch_any?(path, globs)
+      globs.any? { |glob| File.fnmatch(glob, path) }
+    end
+  end
+end

data/lib/i18n/tasks/scanners/files/file_reader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module I18n::Tasks::Scanners::Files
+  # Reads the files in 'rb' mode and UTF-8 encoding.
+  #
+  # @since 0.9.0
+  class FileReader
+    # Return the contents of the file at the given path.
+    # The file is read in the 'rb' mode and UTF-8 encoding.
+    #
+    # @param path [String] Path to the file, absolute or relative to the working directory.
+    # @return [String] file contents
+    def read_file(path)
+      result = nil
+      File.open(path, 'rb', encoding: 'UTF-8') { |f| result = f.read }
+      result
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module I18n::Tasks::Scanners
+  class LocalRubyParser
+    def initialize
+      @parser = ::Parser::CurrentRuby.new
+    end
+
+    # Parse string and normalize location
+    def parse(source, location: nil)
+      buffer = ::Parser::Source::Buffer.new('(string)')
+      buffer.source = source
+
+      @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)
+      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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module I18n
+  module Tasks
+    module Scanners
+      module OccurrenceFromPosition
+        # Given a path to a file, its contents and a position in the file,
+        # return a {Results::Occurrence} at the position until the end of the line.
+        #
+        # @param path [String]
+        # @param contents [String] contents of the file at the path.
+        # @param position [Integer] position just before the beginning of the match.
+        # @return [Results::Occurrence]
+        def occurrence_from_position(path, contents, position, raw_key: nil)
+          line_begin = contents.rindex(/^/, position - 1)
+          line_end   = contents.index(/.(?=\r?\n|$)/, position)
+          Results::Occurrence.new(
+            path: path,
+            pos: position,
+            line_num: contents[0..position].count("\n") + 1,
+            line_pos: position - line_begin + 1,
+            line: contents[line_begin..line_end],
+            raw_key: raw_key
+          )
+        end
+      end
+    end
+  end
+end