rubocop 0.86.0 → 0.89.1

data/lib/rubocop/cop/style/redundant_exception.rb

@@ -16,21 +16,26 @@ module RuboCop
       #
       #   # Good
       #   raise 'message'
-      class RedundantException < Cop
+      class RedundantException < Base
+        extend AutoCorrector
+
         MSG_1 = 'Redundant `RuntimeError` argument can be removed.'
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
-        def on_send(node)
-          exploded?(node) { return add_offense(node, message: MSG_1) }
-          compact?(node) { add_offense(node, message: MSG_2) }
-        end
+        RAISE_METHODS = %i[raise fail].freeze
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def on_send(node)
+          return unless RAISE_METHODS.include?(node.method_name)
+
+          fix_exploded(node) || fix_compact(node)
+        end
+
+        def fix_exploded(node)
           exploded?(node) do |command, message|
-            return lambda do |corrector|
+            add_offense(node, message: MSG_1) do |corrector|
               if node.parenthesized?
                 corrector.replace(node,
                                   "#{command}(#{message.source})")
@@ -40,19 +45,22 @@ module RuboCop
               end
             end
           end
+        end
+
+        def fix_compact(node)
           compact?(node) do |new_call, message|
-            lambda do |corrector|
+            add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, message.source)
             end
           end
         end
 
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
+          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
         def_node_matcher :compact?, <<~PATTERN
-          (send nil? {:raise :fail} $(send (const nil? :RuntimeError) :new $_))
+          (send nil? {:raise :fail} $(send (const {nil? cbase} :RuntimeError) :new $_))
         PATTERN
       end
     end

data/lib/rubocop/cop/style/redundant_fetch_block.rb

@@ -41,13 +41,12 @@ module RuboCop
           (block
             $(send _ :fetch _)
             (args)
-            ${#basic_literal? const_type?})
+            ${nil? #basic_literal? #const_type?})
         PATTERN
 
         def on_block(node)
           redundant_fetch_block_candidate?(node) do |send, body|
-            return if body.const_type? && !check_for_constant?
-            return if body.str_type? && !check_for_string?
+            return if should_not_check?(send, body)
 
             range = fetch_range(send, node)
             good = build_good_method(send, body)
@@ -65,7 +64,9 @@ module RuboCop
           redundant_fetch_block_candidate?(node) do |send, body|
             lambda do |corrector|
               receiver, _, key = send.children
-              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{body.source})")
+              default_value = body ? body.source : 'nil'
+
+              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{default_value})")
             end
           end
         end
@@ -73,21 +74,39 @@ module RuboCop
         private
 
         def basic_literal?(node)
-          node.basic_literal?
+          node&.basic_literal?
+        end
+
+        def const_type?(node)
+          node&.const_type?
+        end
+
+        def should_not_check?(send, body)
+          (body&.const_type? && !check_for_constant?) ||
+            (body&.str_type? && !check_for_string?) ||
+            rails_cache?(send.receiver)
         end
 
+        def_node_matcher :rails_cache?, <<~PATTERN
+          (send (const _ :Rails) :cache)
+        PATTERN
+
         def fetch_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end
 
         def build_good_method(send, body)
           key = send.children[2].source
-          "fetch(#{key}, #{body.source})"
+          default_value = body ? body.source : 'nil'
+
+          "fetch(#{key}, #{default_value})"
         end
 
         def build_bad_method(send, body)
           key = send.children[2].source
-          "fetch(#{key}) { #{body.source} }"
+          block = body ? "{ #{body.source} }" : '{}'
+
+          "fetch(#{key}) #{block}"
         end
 
         def check_for_constant?

data/lib/rubocop/cop/style/redundant_file_extension_in_require.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous `.rb` extension in
+      # the filename provided to `require` and `require_relative`.
+      #
+      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      #       and so on to the name until found. If the file named cannot be found,
+      #       a `LoadError` will be raised.
+      #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`
+      #       if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`,
+      #       but that seems harmless.
+      #
+      # @example
+      #   # bad
+      #   require 'foo.rb'
+      #   require_relative '../foo.rb'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'foo.so'
+      #   require_relative '../foo'
+      #   require_relative '../foo.so'
+      #
+      class RedundantFileExtensionInRequire < Cop
+        MSG = 'Redundant `.rb` file extension detected.'
+
+        def_node_matcher :require_call?, <<~PATTERN
+          (send nil? {:require :require_relative} $str_type?)
+        PATTERN
+
+        def on_send(node)
+          require_call?(node) do |name_node|
+            add_offense(name_node) if name_node.value.end_with?('.rb')
+          end
+        end
+
+        def autocorrect(node)
+          correction = node.value.sub(/\.rb\z/, '')
+
+          lambda do |corrector|
+            corrector.replace(node, "'#{correction}'")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_freeze.rb

@@ -56,7 +56,7 @@ module RuboCop
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
             (begin (send !(str _) {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const nil? :ENV) :[] _)
+            (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -205,7 +205,9 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node)
+          first_send_argument?(node) ||
+            first_super_argument?(node) ||
+            first_yield_argument?(node)
         end
 
         def_node_matcher :first_send_argument?, <<~PATTERN
@@ -216,6 +218,10 @@ module RuboCop
           ^(super equal?(%0) ...)
         PATTERN
 
+        def_node_matcher :first_yield_argument?, <<~PATTERN
+          ^(yield equal?(%0) ...)
+        PATTERN
+
         def call_chain_starts_with_int?(begin_node, send_node)
           recv = first_part_of_call_chain(send_node)
           recv&.int_type? && (parent = begin_node.parent) &&

data/lib/rubocop/cop/style/redundant_regexp_character_class.rb

@@ -34,10 +34,11 @@ module RuboCop
             \[                # Literal [
             (?!\#\{)          # Not (the start of) an interpolation
             (?:               # Either...
-             \\. |            # Any escaped character
+             \\[^b] |         # Any escaped character except b (which would change behaviour)
              [^.*+?{}()|$] |  # or one that doesn't require escaping outside the character class
              \\[upP]\{[^}]+\} # or a unicode code-point or property
             )
+            (?<!\\)           # No \-prefix (i.e. not escaped)
             \]                # Literal ]
           )
         /x.freeze

data/lib/rubocop/cop/style/redundant_regexp_escape.rb

@@ -83,8 +83,8 @@ module RuboCop
 
         def delimiter?(node, char)
           delimiters = [
-            node.loc.begin.source.chars.last,
-            node.loc.end.source.chars.first
+            node.loc.begin.source[-1],
+            node.loc.end.source[0]
           ]
 
           delimiters.include?(char)
@@ -92,18 +92,18 @@ module RuboCop
 
         def each_escape(node)
           pattern_source(node).each_char.with_index.reduce(
-            [nil, false]
-          ) do |(previous, within_character_class), (current, index)|
+            [nil, 0]
+          ) do |(previous, char_class_depth), (current, index)|
             if previous == '\\'
-              yield [current, index - 1, within_character_class]
+              yield [current, index - 1, !char_class_depth.zero?]
 
-              [nil, within_character_class]
-            elsif previous == '[' && current != ':'
-              [current, true]
-            elsif previous != ':' && current == ']'
-              [current, false]
+              [nil, char_class_depth]
+            elsif previous == '['
+              [current, char_class_depth + 1]
+            elsif current == ']'
+              [current, char_class_depth - 1]
             else
-              [current, within_character_class]
+              [current, char_class_depth]
             end
           end
         end

data/lib/rubocop/cop/style/redundant_sort.rb

@@ -55,6 +55,8 @@ module RuboCop
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
+        SORT_METHODS = %i[sort sort_by].freeze
+
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
@@ -72,18 +74,21 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          redundant_sort?(node) do |sort_node, sorter, accessor|
-            range = range_between(
-              sort_node.loc.selector.begin_pos,
-              node.loc.expression.end_pos
-            )
+          return unless sort_method?(node)
 
-            add_offense(node,
-                        location: range,
-                        message: message(node,
-                                         sorter,
-                                         accessor))
+          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
+            ancestor = node.parent
+          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
+            ancestor = node.parent.parent
+          else
+            return
           end
+
+          add_offense(ancestor,
+                      location: offense_range(sort_node, ancestor),
+                      message: message(ancestor,
+                                       sorter,
+                                       accessor))
         end
 
         def autocorrect(node)
@@ -108,6 +113,14 @@ module RuboCop
 
         private
 
+        def sort_method?(node)
+          SORT_METHODS.include?(node.method_name)
+        end
+
+        def offense_range(sort_node, ancestor)
+          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        end
+
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,
@@ -135,9 +148,10 @@ module RuboCop
         end
 
         def suffix(sorter)
-          if sorter == :sort
+          case sorter
+          when :sort
             ''
-          elsif sorter == :sort_by
+          when :sort_by
             '_by'
           end
         end

data/lib/rubocop/cop/style/rescue_standard_error.rb

@@ -85,7 +85,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :rescue_standard_error?, <<~PATTERN
-          (resbody $(array (const nil? :StandardError)) _ _)
+          (resbody $(array (const {nil? cbase} :StandardError)) _ _)
         PATTERN
 
         def on_resbody(node)

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -136,10 +136,10 @@ module RuboCop
         end
 
         def comments(node)
-          processed_source.comments.select do |comment|
-            comment.loc.first_line > node.loc.first_line &&
-              comment.loc.last_line < node.loc.last_line
-          end
+          processed_source.each_comment_in_lines(
+            node.loc.first_line...
+            node.loc.last_line
+          ).to_a
         end
 
         def allowed_if_condition?(node)

data/lib/rubocop/cop/style/signal_exception.rb

@@ -111,7 +111,7 @@ module RuboCop
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'
 
-        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
+        def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
@@ -191,6 +191,8 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
+          return unless node.method?(name)
+
           node.command?(name) || kernel_call?(node, name)
         end
 

data/lib/rubocop/cop/style/single_argument_dig.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sometimes using dig method ends up with just a single
+      # argument. In such cases, dig should be replaced with [].
+      #
+      # @example
+      #   # bad
+      #   { key: 'value' }.dig(:key)
+      #   [1, 2, 3].dig(0)
+      #
+      #   # good
+      #   { key: 'value' }[:key]
+      #   [1, 2, 3][0]
+      #
+      #   # good
+      #   { key1: { key2: 'value' } }.dig(:key1, :key2)
+      #   [1, [2, [3]]].dig(1, 1)
+      #
+      #   # good
+      #   keys = %i[key1 key2]
+      #   { key1: { key2: 'value' } }.dig(*keys)
+      #
+      class SingleArgumentDig < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
+
+        def_node_matcher :single_argument_dig?, <<~PATTERN
+          (send _ :dig $!splat)
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+
+          expression = single_argument_dig?(node)
+          return unless expression
+
+          receiver = node.receiver.source
+          argument = expression.source
+
+          message = format(MSG, receiver: receiver, argument: argument,
+                                original: node.source)
+          add_offense(node, message: message) do |corrector|
+            correct_access = "#{receiver}[#{argument}]"
+            corrector.replace(node, correct_access)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/single_line_methods.rb

@@ -73,7 +73,7 @@ module RuboCop
 
         def move_comment(node, corrector)
           LineBreakCorrector.move_comment(
-            eol_comment: end_of_line_comment(node.source_range.line),
+            eol_comment: processed_source.comment_at_line(node.source_range.line),
             node: node, corrector: corrector
           )
         end

data/lib/rubocop/cop/style/stabby_lambda_parentheses.rb

@@ -34,9 +34,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if style == :require_parentheses
+          case style
+          when :require_parentheses
             missing_parentheses_corrector(node)
-          elsif style == :require_no_parentheses
+          when :require_no_parentheses
             unwanted_parentheses_corrector(node)
           end
         end