rubocop 0.47.1 → 0.48.0

data/lib/rubocop/cop/lint/empty_ensure.rb

@@ -46,9 +46,13 @@ module RuboCop
         MSG = 'Empty `ensure` block detected.'.freeze
 
         def on_ensure(node)
-          _body, ensure_body = *node
+          add_offense(node, :keyword) unless node.body
+        end
 
-          add_offense(node, :keyword) unless ensure_body
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.keyword)
+          end
         end
       end
     end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -29,7 +29,7 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'.freeze
 
         def on_ensure(node)
-          _body, ensure_body = *node
+          ensure_body = node.body
 
           return unless ensure_body
 

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -29,11 +29,13 @@ module RuboCop
         SHOVEL = '<<'.freeze
         PERCENT = '%'.freeze
         PERCENT_PERCENT = '%%'.freeze
-        STRING_TYPES = [:str, :dstr].freeze
+        STRING_TYPES = %i(str dstr).freeze
         NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
 
         def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
+          return unless offending_node?(node)
+
+          add_offense(node, :selector)
         end
 
         private
@@ -41,7 +43,7 @@ module RuboCop
         def offending_node?(node)
           return false unless called_on_string?(node)
           return false unless method_with_format_args?(node)
-          return false if named_mode?(node) || node_with_splat_args?(node)
+          return false if named_mode?(node) || splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
@@ -82,18 +84,14 @@ module RuboCop
           !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
         end
 
-        def node_with_splat_args?(node)
+        def splat_args?(node)
           return false if percent?(node)
 
-          _receiver_node, _method_name, *args = *node
-
-          args.butfirst.any?(&:splat_type?)
+          node.arguments.butfirst.any?(&:splat_type?)
         end
 
         def heredoc?(node)
-          _receiver, _name, args = *node
-
-          args.source[0, 2] == SHOVEL
+          node.first_argument.source[0, 2] == SHOVEL
         end
 
         def count_matches(node)
@@ -131,7 +129,7 @@ module RuboCop
           node
             .source
             .scan(FIELD_REGEX)
-            .select { |x| x.first != PERCENT_PERCENT }
+            .reject { |x| x.first == PERCENT_PERCENT }
             .reduce(0) { |acc, elem| acc + (elem[2] =~ /\*/ ? 2 : 1) }
         end
 
@@ -154,13 +152,13 @@ module RuboCop
         end
 
         def percent?(node)
-          receiver_node, method_name, *arg_nodes = *node
+          receiver = node.receiver
 
-          percent = method_name == :% &&
-                    (STRING_TYPES.include?(receiver_node.type) ||
-                     arg_nodes[0].array_type?)
+          percent = node.method_name == :% &&
+                    (STRING_TYPES.include?(receiver.type) ||
+                     node.first_argument.array_type?)
 
-          if percent && STRING_TYPES.include?(receiver_node.type)
+          if percent && STRING_TYPES.include?(receiver.type)
             return false if heredoc?(node)
           end
 
@@ -168,10 +166,14 @@ module RuboCop
         end
 
         def message(node)
-          _receiver, method_name, *_args = *node
           num_args_for_format, num_expected_fields = count_matches(node)
 
-          method_name = 'String#%' if PERCENT == method_name.to_s
+          method_name = if node.method_name.to_s == PERCENT
+                          'String#%'
+                        else
+                          node.method_name
+                        end
+
           format(MSG, num_args_for_format, method_name, num_expected_fields)
         end
       end

data/lib/rubocop/cop/lint/handle_exceptions.rb

@@ -48,9 +48,7 @@ module RuboCop
         MSG = 'Do not suppress exceptions.'.freeze
 
         def on_resbody(node)
-          _exc_list_node, _exc_var_node, body_node = *node
-
-          add_offense(node, :expression) unless body_node
+          add_offense(node, :expression) unless node.body
         end
       end
     end

data/lib/rubocop/cop/lint/literal_in_condition.rb

@@ -108,7 +108,7 @@ module RuboCop
         def handle_node(node)
           if node.literal?
             add_offense(node, :expression)
-          elsif [:send, :and, :or, :begin].include?(node.type)
+          elsif %i(send and or begin).include?(node.type)
             check_node(node)
           end
         end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -18,7 +18,7 @@ module RuboCop
       #   "result is 10"
       class LiteralInInterpolation < Cop
         MSG = 'Literal interpolation detected.'.freeze
-        COMPOSITE = [:array, :hash, :pair, :irange, :erange].freeze
+        COMPOSITE = %i(array hash pair irange erange).freeze
 
         def on_dstr(node)
           node.each_child_node(:begin) do |begin_node|

data/lib/rubocop/cop/lint/multiple_compare.rb

@@ -22,7 +22,7 @@ module RuboCop
       #   x < y && y < z
       #   10 <= x && x <= 20
       class MultipleCompare < Cop
-        MSG = 'Use `&&` operator to compare multiple value.'.freeze
+        MSG = 'Use the `&&` operator to compare multiple values.'.freeze
 
         def_node_matcher :multiple_compare?, <<-PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
@@ -30,13 +30,15 @@ module RuboCop
 
         def on_send(node)
           return unless multiple_compare?(node)
+
           add_offense(node, :expression)
         end
 
         def autocorrect(node)
+          center = multiple_compare?(node)
+          new_center = "#{center.source} && #{center.source}"
+
           lambda do |corrector|
-            center = multiple_compare?(node)
-            new_center = "#{center.source} && #{center.source}"
             corrector.replace(center.source_range, new_center)
           end
         end

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -3,11 +3,16 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for non-local exit from iterator, without return value.
-      # It warns only when satisfies all of these: `return` doesn't have return
-      # value, the block is preceded by a method chain, the block has arguments,
-      # and the method which receives the block is not `define_method`
-      # or `define_singleton_method`.
+      # This cop checks for non-local exits from iterators without a return
+      # value. It registers an offense under these conditions:
+      #
+      #  - No value is returned,
+      #  - the block is preceded by a method chain,
+      #  - the block has arguments,
+      #  - the method which receives the block is not `define_method`
+      #    or `define_singleton_method`,
+      #  - the return is not contained in an inner scope, e.g. a lambda or a
+      #    method definition.
       #
       # @example
       #
@@ -40,17 +45,19 @@ module RuboCop
 
         def on_return(return_node)
           return if return_value?(return_node)
-          return_node.each_ancestor(:block) do |block_node|
-            send_node, args_node, _body_node = *block_node
 
-            # `return` does not exit to outside of lambda block, this is safe.
-            break if block_node.lambda?
+          return_node.each_ancestor(:block, :def, :defs) do |node|
+            break if scoped_node?(node)
+
+            send_node, args_node, _body_node = *node
+
             # if a proc is passed to `Module#define_method` or
             # `Object#define_singleton_method`, `return` will not cause a
             # non-local exit error
             break if define_method?(send_node)
 
             next if args_node.children.empty?
+
             if chained_send?(send_node)
               add_offense(return_node, :keyword)
               break
@@ -58,19 +65,20 @@ module RuboCop
           end
         end
 
-        def return_value?(return_node)
-          !return_node.children.empty?
-        end
+        private
 
-        def chained_send?(send_node)
-          receiver_node, _selector_node = *send_node
-          !receiver_node.nil?
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
         end
 
-        def define_method?(send_node)
-          _receiver, selector = *send_node
-          %i(define_method define_singleton_method).include? selector
+        def return_value?(return_node)
+          !return_node.children.empty?
         end
+
+        def_node_matcher :chained_send?, '(send !nil ...)'
+        def_node_matcher :define_method?, <<-PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -21,23 +21,22 @@ module RuboCop
         MSG = '`(...)` interpreted as grouped expression.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless args.one?
-          return if operator?(method_name) || node.asgn_method_call?
+          return unless node.arguments.one?
+          return if node.operator_method? || node.setter_method?
 
-          first_arg = args.first
-          return unless first_arg.source.start_with?('(')
+          return unless node.first_argument.source.start_with?('(')
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length > 0
 
-          add_offense(nil, space_range(first_arg.source_range, space_length))
+          add_offense(nil, space_range(node.first_argument.source_range,
+                                       space_length))
         end
 
         private
 
         def spaces_before_left_parenthesis(node)
-          receiver, method_name, _args = *node
+          receiver = node.receiver
           receiver_length = if receiver
                               receiver.source.length
                             else
@@ -46,7 +45,7 @@ module RuboCop
           without_receiver = node.source[receiver_length..-1]
 
           # Escape question mark if any.
-          method_regexp = Regexp.escape(method_name)
+          method_regexp = Regexp.escape(node.method_name)
 
           match = without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/)
           match ? match.captures[0].length : 0

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -30,21 +30,19 @@ module RuboCop
               'precedence.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
+          return if !node.arguments? || node.parenthesized?
 
-          return if parentheses?(node) || args.empty?
-
-          if args.first.if_type? && args.first.ternary?
-            check_ternary(args.first, node)
-          elsif method_name.to_s.end_with?('?')
-            check_predicate(args.last, node)
+          if node.first_argument.if_type? && node.first_argument.ternary?
+            check_ternary(node.first_argument, node)
+          elsif node.predicate_method?
+            check_predicate(node.last_argument, node)
           end
         end
 
         private
 
         def check_ternary(ternary, node)
-          return unless offense?(ternary.condition)
+          return unless ternary.condition.operator_keyword?
 
           range = range_between(node.source_range.begin_pos,
                                 ternary.condition.source_range.end_pos)
@@ -53,14 +51,10 @@ module RuboCop
         end
 
         def check_predicate(predicate, node)
-          return unless offense?(predicate)
+          return unless predicate.operator_keyword?
 
           add_offense(node, :expression)
         end
-
-        def offense?(node)
-          [:and, :or].include?(node.type)
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -29,8 +29,6 @@ module RuboCop
         MSG = 'Do not chain ordinary method call' \
               ' after safe navigation operator.'.freeze
 
-        ADDITIONAL_NIL_METHODS = %i(present? blank? try).freeze
-
         def_node_matcher :bad_method?, <<-PATTERN
           (send (csend ...) $_ ...)
         PATTERN
@@ -42,12 +40,14 @@ module RuboCop
             return if nil_methods.include?(method)
 
             loc = node.loc.dot || :selector
+
             add_offense(node, loc)
           end
         end
 
         def autocorrect(node)
           dot = node.loc.dot
+
           return unless dot
 
           lambda do |corrector|
@@ -58,7 +58,11 @@ module RuboCop
         private
 
         def nil_methods
-          nil.methods + ADDITIONAL_NIL_METHODS
+          nil.methods + whitelist
+        end
+
+        def whitelist
+          cop_config['Whitelist'].map(&:to_sym)
         end
       end
     end

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -31,6 +31,8 @@ module RuboCop
       #     handle_exception
       #   end
       class ShadowedException < Cop
+        include RescueNode
+
         MSG = 'Do not shadow rescued Exceptions.'.freeze
 
         def on_rescue(node)
@@ -68,12 +70,6 @@ module RuboCop
           range_between(first_rescue.loc.expression.begin_pos, end_pos)
         end
 
-        def rescue_modifier?(node)
-          node && node.rescue_type? &&
-            (node.parent.nil? || !(node.parent.kwbegin_type? ||
-             node.parent.ensure_type?))
-        end
-
         def contains_multiple_levels_of_exceptions?(group)
           if group.size > 1 && group.include?(Exception)
             # Treat `Exception` as the highest level exception unless `nil` was

data/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -25,21 +25,20 @@ module RuboCop
         def on_dstr(node)
           node.each_child_node(:begin) do |begin_node|
             final_node = begin_node.children.last
-            next unless final_node && final_node.send_type?
 
-            receiver, method_name, *args = *final_node
-            next unless method_name == :to_s && args.empty?
+            next unless final_node && final_node.send_type? &&
+                        final_node.method?(:to_s) && !final_node.arguments?
 
-            add_offense(
-              final_node,
-              :selector,
-              receiver ? MSG_DEFAULT : MSG_SELF
-            )
+            add_offense(final_node, :selector)
           end
         end
 
         private
 
+        def message(node)
+          node.receiver ? MSG_DEFAULT : MSG_SELF
+        end
+
         def autocorrect(node)
           lambda do |corrector|
             receiver, _method_name, *_args = *node

data/lib/rubocop/cop/lint/unneeded_disable.rb

@@ -70,7 +70,8 @@ module RuboCop
           range_with_surrounding_space(range, :right, false)
         end
 
-        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments)
+        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
+                                  &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
@@ -78,16 +79,23 @@ module RuboCop
               yield comment, cop
             end
 
-            line_ranges.each do |line_range|
-              comment = comments.find { |c| c.loc.line == line_range.begin }
+            each_line_range(line_ranges, disabled_ranges, offenses, comments,
+                            cop, &block)
+          end
+        end
 
-              unless all_disabled?(comment)
-                next if ignore_offense?(disabled_ranges, line_range)
-              end
+        def each_line_range(line_ranges, disabled_ranges, offenses, comments,
+                            cop)
+          line_ranges.each_with_index do |line_range, ix|
+            comment = comments.find { |c| c.loc.line == line_range.begin }
 
-              unneeded_cop = find_unneeded(comment, offenses, cop, line_range)
-              yield comment, unneeded_cop if unneeded_cop
+            unless all_disabled?(comment)
+              next if ignore_offense?(disabled_ranges, line_range)
             end
+
+            unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
+                                         line_ranges[ix + 1])
+            yield comment, unneeded_cop if unneeded_cop
           end
         end
 
@@ -99,13 +107,29 @@ module RuboCop
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's unneeded
             # whether there are offenses or not.
-            yield comments.find { |c| c.loc.line == range.begin }
+            unneeded_comment = comments.find do |c|
+              c.loc.line == range.begin &&
+                # Comments disabling all cops don't count since it's reasonable
+                # to disable a few select cops first and then all cops further
+                # down in the code.
+                !all_disabled?(c)
+            end
+            yield unneeded_comment if unneeded_comment
           end
         end
 
-        def find_unneeded(comment, offenses, cop, line_range)
+        def find_unneeded(comment, offenses, cop, line_range, next_line_range)
           if all_disabled?(comment)
-            'all' if offenses.none? { |o| line_range.cover?(o.line) }
+            # If there's a disable all comment followed by a comment
+            # specifically disabling `cop`, we don't report the `all`
+            # comment. If the disable all comment is truly unneeded, we will
+            # detect that when examining the comments of another cop, and we
+            # get the full line range for the disable all.
+            if (next_line_range.nil? ||
+                line_range.last != next_line_range.first) &&
+               offenses.none? { |o| line_range.cover?(o.line) }
+              'all'
+            end
           else
             cop_offenses = offenses.select { |o| o.cop_name == cop }
             cop if cop_offenses.none? { |o| line_range.cover?(o.line) }