i18n-tasks 0.9.6 → 0.9.7

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

@@ -7,12 +7,11 @@ module I18n::Tasks::Scanners::Files
   # @note This class is thread-safe. All methods are cached.
   # @since 0.9.0
   class CachingFileFinderProvider
-
     # @param exclude [Array<String>]
     def initialize(exclude: [])
       @cache = {}
       @mutex = Mutex.new
-      @defaults = {exclude: exclude}
+      @defaults = { exclude: exclude }
     end
 
     # Initialize a {CachingFileFinder} or get one from cache based on the constructor arguments.

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

@@ -7,7 +7,6 @@ module I18n::Tasks::Scanners::Files
   # @note This class is thread-safe. All methods are cached.
   # @since 0.9.0
   class CachingFileReader < FileReader
-
     def initialize
       super
       @mutex = Mutex.new

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

@@ -13,7 +13,7 @@ module I18n::Tasks::Scanners::Files
     # @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: [])
-      raise 'paths argument is required' if paths.nil?
+      fail 'paths argument is required' if paths.nil?
       @paths   = paths
       @include = only
       @exclude = exclude || []
@@ -29,22 +29,19 @@ module I18n::Tasks::Scanners::Files
     end
 
     # @return [Array<String>] found files
-    def find_files
+    def find_files # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       results = []
       paths = @paths.select { |p| File.exist?(p) }
-      if paths.empty?
-        log_warn "None of the search.paths exist #{@paths.inspect}"
-      else
-        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
+      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

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

@@ -4,7 +4,6 @@ module I18n::Tasks::Scanners::Files
   #
   # @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.
     #

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

@@ -8,18 +8,19 @@ module I18n
         #
         # @param path [String]
         # @param contents [String] contents of the file at the path.
-        # @param position [Fixnum] position just before the beginning of the match.
+        # @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".freeze) + 1,
-              line_pos: position - line_begin + 1,
-              line:     contents[line_begin..line_end],
-              raw_key: raw_key)
+            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

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

@@ -40,7 +40,7 @@ module I18n::Tasks::Scanners
             next unless valid_key?(matches[:key])
           end
           result << [absolute_key(key % matches, path),
-           occurrence_from_position(path, text, match.offset(0).first)]
+                     occurrence_from_position(path, text, match.offset(0).first)]
         end
         result
       end
@@ -52,7 +52,7 @@ module I18n::Tasks::Scanners
 
     def configure_patterns(patterns)
       patterns.map do |(pattern, key)|
-        [pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern % {key: KEY_GROUP}), key]
+        [pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern % { key: KEY_GROUP }), key]
       end
     end
   end

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

@@ -13,8 +13,10 @@ module I18n::Tasks::Scanners
 
     def initialize(**args)
       super
-      @pattern          = config[:pattern].present? ? Regexp.new(config[:pattern]) : default_pattern
-      @ignore_lines_res = (config[:ignore_lines] || []).inject({}) { |h, (ext, re)| h.update(ext.to_s => Regexp.new(re)) }
+      @pattern = config[:pattern].present? ? Regexp.new(config[:pattern]) : default_pattern
+      @ignore_lines_res = (config[:ignore_lines] || []).each_with_object({}) do |(ext, re), h|
+        h[ext.to_s] = Regexp.new(re)
+      end
     end
 
     protected
@@ -25,17 +27,17 @@ module I18n::Tasks::Scanners
       keys = []
       text = read_file(path)
       text.scan(@pattern) do |match|
-        src_pos  = Regexp.last_match.offset(0).first
+        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 = key + ':'.freeze if key.end_with?('.'.freeze)
+        key += ':' if key.end_with?('.')
         next unless valid_key?(key)
         keys << [key, location]
       end
       keys
-    rescue Exception => e
+    rescue Exception => e # rubocop:disable Lint/RescueException
       raise ::I18n::Tasks::CommandError.new(e, "Error scanning #{path}: #{e.message}")
     end
 
@@ -67,8 +69,8 @@ module I18n::Tasks::Scanners
     end
 
     def closest_method(occurrence)
-      method = File.readlines(occurrence.path, encoding: 'UTF-8'.freeze).
-          first(occurrence.line_num - 1).reverse_each.find { |x| x =~ /\bdef\b/ }
+      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;].*$/, '')
     end
 

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

@@ -6,7 +6,6 @@ module I18n::Tasks::Scanners
   # both scope: "literal", and scope: [:array, :of, 'literals'] forms are supported
   # Caveat: scope is only detected when it is the first argument
   class PatternWithScopeScanner < PatternScanner
-
     protected
 
     def default_pattern
@@ -24,7 +23,7 @@ module I18n::Tasks::Scanners
       key   = super
       scope = match[1]
       if scope
-        scope_ns = scope.gsub(/[\[\]\s]+/, ''.freeze).split(','.freeze).map { |arg| strip_literal(arg) } * '.'.freeze
+        scope_ns = scope.gsub(/[\[\]\s]+/, '').split(',').map { |arg| strip_literal(arg) } * '.'
         "#{scope_ns}.#{key}"
       else
         key unless match[0] =~ /\A\w/

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

@@ -12,40 +12,40 @@ module I18n
           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) or
-              fail CommandError.new("Cannot resolve relative key \"#{key}\".\n" +
-                                        "Set search.relative_roots in config/i18n-tasks.yml (currently #{roots.inspect})")
-          normalized_path.sub!(root, ''.freeze)
+          (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})")
+          normalized_path.sub!(root, '')
           "#{prefix(normalized_path, calling_method: calling_method)}#{key}"
         end
 
         private
 
-        DOT = '.'.freeze
+        DOT = '.'
 
         # Detect the appropriate relative path root
         # @param [String] path /full/path
         # @param [Array<String>] roots array of full paths
         # @return [String] the closest ancestor root for path, with a trailing {File::SEPARATOR}.
         def path_root(path, roots)
-          roots.map { |p|
+          roots.map do |p|
             File.expand_path(p) + File::SEPARATOR
-          }.sort.reverse_each.detect { |root|
+          end.sort.reverse_each.detect do |root|
             path.start_with?(root)
-          }
+          end
         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)
-          file_key       = normalized_path.gsub(%r((\.[^/]+)*$), ''.freeze).tr(File::SEPARATOR, DOT)
+          file_key       = normalized_path.gsub(%r{(\.[^/]+)*$}, '').tr(File::SEPARATOR, DOT)
           calling_method = calling_method.call if calling_method.respond_to?(:call)
           if calling_method && calling_method.present?
             # Relative keys in mailers have a `_mailer` infix, but relative keys in controllers do not have one:
-            "#{file_key.sub(/_controller$/, ''.freeze)}.#{calling_method}"
+            "#{file_key.sub(/_controller$/, '')}.#{calling_method}"
           else
             # Remove _ prefix from partials
-            file_key.gsub(%r(\._), DOT)
+            file_key.gsub(/\._/, DOT)
           end
         end
       end

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

@@ -40,15 +40,14 @@ module I18n::Tasks::Scanners::Results
     # @param keys_occurrences [Enumerable<KeyOccurrences>]
     # @return [Array<KeyOccurrences>] a new array.
     def self.merge_keys(keys_occurrences)
-      keys_occurrences.inject({}) { |results_by_key, key_occurrences|
+      keys_occurrences.each_with_object({}) do |key_occurrences, results_by_key|
         (results_by_key[key_occurrences.key] ||= []) << key_occurrences.occurrences
-        results_by_key
-      }.map { |key, all_occurrences|
+      end.map do |key, all_occurrences|
         occurrences = all_occurrences.flatten(1)
         occurrences.sort_by!(&:path)
         occurrences.uniq!
         new(key: key, occurrences: occurrences)
-      }
+      end
     end
   end
 end

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

@@ -9,13 +9,13 @@ module I18n::Tasks
         # @return [String] source path relative to the current working directory.
         attr_reader :path
 
-        # @return [Fixnum] count of characters in the file before the occurrence.
+        # @return [Integer] count of characters in the file before the occurrence.
         attr_reader :pos
 
-        # @return [Fixnum] line number of the occurrence, counting from 1.
+        # @return [Integer] line number of the occurrence, counting from 1.
         attr_reader :line_num
 
-        # @return [Fixnum] position of the start of the occurrence in the line, counting from 1.
+        # @return [Integer] position of the start of the occurrence in the line, counting from 1.
         attr_reader :line_pos
 
         # @return [String] the line of the occurrence, excluding the last LF or CRLF.
@@ -28,12 +28,13 @@ module I18n::Tasks
         attr_accessor :raw_key
 
         # @param path        [String]
-        # @param pos         [Fixnum]
-        # @param line_num    [Fixnum]
-        # @param line_pos    [Fixnum]
+        # @param pos         [Integer]
+        # @param line_num    [Integer]
+        # @param line_pos    [Integer]
         # @param line        [String]
         # @param raw_key     [String, nil]
         # @param default_arg [String, nil]
+        # rubocop:disable Metrics/ParameterLists
         def initialize(path:, pos:, line_num:, line_pos:, line:, raw_key: nil, default_arg: nil)
           @path        = path
           @pos         = pos
@@ -50,7 +51,7 @@ module I18n::Tasks
 
         def ==(other)
           other.path == @path && other.pos == @pos && other.line_num == @line_num && other.line == @line &&
-              other.raw_key == @raw_key && other.default_arg == @default_arg
+            other.raw_key == @raw_key && other.default_arg == @default_arg
         end
 
         def eql?(other)

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

@@ -46,8 +46,8 @@ module I18n::Tasks::Scanners
       receiver = send_node.children[0]
       message  = send_node.children[1]
       if @messages.include?(message) &&
-          # use `any?` because `include?` checks type equality, but the receiver is a Parser::AST::Node != AST::Node.
-          @receivers.any? { |r| r == receiver }
+         # use `any?` because `include?` checks type equality, but the receiver is a Parser::AST::Node != AST::Node.
+         @receivers.any? { |r| r == receiver }
         @callback.call(send_node, @method_name)
       else
         handler_missing send_node

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

@@ -4,13 +4,16 @@ require 'i18n/tasks/scanners/relative_keys'
 require 'i18n/tasks/scanners/ruby_ast_call_finder'
 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
+  class RubyAstScanner < FileScanner # rubocop:disable Metrics/ClassLength
     include RelativeKeys
     include AST::Sexp
 
-    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/.freeze
+    MAGIC_COMMENT_PREFIX = /\A.\s*i18n-tasks-use\s+/
 
     def initialize(messages: %i(t translate), receivers: [nil, s(:const, nil, :I18n)], **args)
       super(args)
@@ -41,13 +44,13 @@ module I18n::Tasks::Scanners
         @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('; ')))
+          @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
-    rescue Exception => e
+    rescue Exception => e # rubocop:disable Lint/RescueException
       raise ::I18n::Tasks::CommandError.new(e, "Error scanning #{path}: #{e.message}")
     end
 
@@ -57,16 +60,16 @@ module I18n::Tasks::Scanners
     # @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))
+         (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'.freeze))
+           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: '.'.freeze, array_flatten: true, array_reject_blank: true)
+                                   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 == ''.freeze
+            key = [scope, key].join('.') unless scope == ''
           end
-          default_arg = if (default_arg_node = extract_hash_pair(second_arg_node, 'default'.freeze))
+          default_arg = if (default_arg_node = extract_hash_pair(second_arg_node, 'default'))
                           extract_string(default_arg_node.children[1])
                         end
         end
@@ -86,11 +89,11 @@ module I18n::Tasks::Scanners
     # @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 { |child|
+      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.
@@ -111,16 +114,17 @@ module I18n::Tasks::Scanners
       elsif %i(true false).include?(node.type)
         node.type.to_s
       elsif :nil == node.type
-        ''.freeze
+        ''
       elsif :array == node.type && 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 { |str|
+          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)
@@ -153,10 +157,12 @@ module I18n::Tasks::Scanners
           end
         end
       end
-      children_strings.reject! { |x|
-        # empty strings and nils in the scope argument are ignored by i18n
-        x == ''.freeze
-      } if array_reject_blank
+      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
 
@@ -170,13 +176,14 @@ module I18n::Tasks::Scanners
     # @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)
+        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.
@@ -186,9 +193,10 @@ module I18n::Tasks::Scanners
     # @param contents [String]
     # @return [Parser::Source::Buffer] file contents
     def make_buffer(path, contents = read_file(path))
-      Parser::Source::Buffer.new(path).tap { |buffer|
+      Parser::Source::Buffer.new(path).tap do |buffer|
         buffer.raw_source = contents
-      }
+      end
     end
   end
 end
+# rubocop:enable Metrics/AbcSize,Metrics/BlockNesting,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity