rubocop 1.6.1 → 1.7.0

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

@@ -106,23 +106,13 @@ module RuboCop
           error && error.ancestors[1] == SystemCallError
         end
 
-        def silence_warnings
-          # Replaces Kernel::silence_warnings since it hides any warnings,
-          # including the RuboCop ones
-          old_verbose = $VERBOSE
-          $VERBOSE = nil
-          yield
-        ensure
-          $VERBOSE = old_verbose
-        end
-
         def evaluate_exceptions(group)
           rescued_exceptions = group.exceptions
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
-                silence_warnings do
+                RuboCop::Util.silence_warnings do
                   # Avoid printing deprecation warnings about constants
                   converted << Kernel.const_get(exception.source)
                 end

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

@@ -9,6 +9,12 @@ module RuboCop
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
+      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      #
+      # `IgnoredPatterns` can be used to match against the block receiver in order to allow
+      # code that would otherwise be registered as an offense (eg. `times` used not in an
+      # `Enumerable` context).
+      #
       # @example
       #   # bad
       #   while node
@@ -70,7 +76,16 @@ module RuboCop
       #     raise NotFoundError
       #   end
       #
+      #   # bad
+      #   2.times { raise ArgumentError }
+      #
+      # @example IgnoredPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      #
+      #   # good
+      #   exactly(2).times { raise StandardError }
       class UnreachableLoop < Base
+        include IgnoredPattern
+
         MSG = 'This loop will have at most one iteration.'
 
         def on_while(node)
@@ -91,6 +106,8 @@ module RuboCop
           return false unless node.block_type?
 
           send_node = node.send_node
+          return false if matches_ignored_pattern?(send_node.source)
+
           send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
         end
 

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -124,7 +124,7 @@ module RuboCop
           end
 
           def classlike_node?(node)
-            CLASSLIKE_TYPES.include?(node.type)
+            CLASSLIKE_TYPES.include?(node&.type)
           end
 
           def foldable_node?(node)

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -4,7 +4,9 @@ module RuboCop
   module Cop
     module Naming
       # This cop checks for memoized methods whose instance variable name
-      # does not match the method name.
+      # does not match the method name. Applies to both regular methods
+      # (defined with `def`) and dynamic methods (defined with
+      # `define_method` or `define_singleton_method`).
       #
       # This cop can be configured with the EnforcedStyleForLeadingUnderscores
       # directive. It can be configured to allow for memoized instance variables
@@ -48,6 +50,17 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing(helper_variable)
       #   end
       #
+      #   # good
+      #   define_method(:foo) do
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     return @foo if defined?(@foo)
+      #     @foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores: required
       #   # bad
       #   def foo
@@ -79,6 +92,17 @@ module RuboCop
       #     @_foo = calculate_expensive_thing
       #   end
       #
+      #   # good
+      #   define_method(:foo) do
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores :optional
       #   # bad
       #   def foo
@@ -105,6 +129,16 @@ module RuboCop
       #     return @_foo if defined?(@_foo)
       #     @_foo = calculate_expensive_thing
       #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     @_foo ||= calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 
@@ -112,17 +146,27 @@ module RuboCop
           'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
           'with `_`. Use `@%<suggested_var>s` instead.'
+        DYNAMIC_DEFINE_METHODS = %i[define_method define_singleton_method].to_set.freeze
+
+        def_node_matcher :method_definition?, <<~PATTERN
+          ${
+            (block (send _ %DYNAMIC_DEFINE_METHODS ({sym str} $_)) ...)
+            (def $_ ...)
+            (defs _ $_ ...)
+          }
+        PATTERN
 
         # rubocop:disable Metrics/AbcSize
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
-          return unless (method_node = node.each_ancestor(:def, :defs).first)
+
+          method_node, method_name = find_definition(node)
+          return unless method_node
 
           body = method_node.body
           return unless body == node || body.children.last == node
 
-          method_name = method_node.method_name
           return if matches?(method_name, lhs)
 
           msg = format(
@@ -147,11 +191,10 @@ module RuboCop
           arg = node.arguments.first
           return unless arg.ivar_type?
 
-          method_node = node.each_ancestor(:def, :defs).first
+          method_node, method_name = find_definition(node)
           return unless method_node
 
           var_name = arg.children.first
-          method_name = method_node.method_name
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
             return if matches?(method_name, ivar_assign)
 
@@ -174,6 +217,17 @@ module RuboCop
           'EnforcedStyleForLeadingUnderscores'
         end
 
+        def find_definition(node)
+          # Methods can be defined in a `def` or `defs`,
+          # or dynamically via a `block` node.
+          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+            method_node, method_name = method_definition?(ancestor)
+            return [method_node, method_name] if method_node
+          end
+
+          nil
+        end
+
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || method_name == :initialize
 

data/lib/rubocop/cop/registry.rb

@@ -204,6 +204,12 @@ module RuboCop
         to_h[cop_name].first
       end
 
+      def freeze
+        clear_enrollment_queue
+        unqualified_cop_names # build cache
+        super
+      end
+
       @global = new
 
       class << self
@@ -228,6 +234,10 @@ module RuboCop
         @global = previous
       end
 
+      def self.reset!
+        @global = new
+      end
+
       private
 
       def initialize_copy(reg)

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

@@ -87,7 +87,9 @@ module RuboCop
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) if opposite_style_detected
+            add_offense(node.loc.selector) do
+              opposite_style_detected
+            end
           else
             correct_style_detected
           end

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

@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments.one? && node.first_argument.block_pass_type?
+          return unless implicit_block?(node)
 
           check_method_node(node)
         end
@@ -64,9 +64,22 @@ module RuboCop
           end
         end
 
+        def implicit_block?(node)
+          return false unless node.arguments.any?
+
+          node.last_argument.block_pass_type? ||
+            node.last_argument.sym_type? && methods_accepting_symbol.include?(node.method_name.to_s)
+        end
+
         def message(node)
           format(MSG, prefer: preferred_method(node.method_name), current: node.method_name)
         end
+
+        # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead
+        # of a block.
+        def methods_accepting_symbol
+          Array(cop_config['MethodsAcceptingSymbol'])
+        end
       end
     end
   end

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

@@ -4,12 +4,15 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for comments put on the same line as some keywords.
-      # These keywords are: `begin`, `class`, `def`, `end`, `module`.
+      # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
       # are allowed.
       #
+      # Auto-correction removes comments from `end` keyword and keeps comments
+      # for `class`, `module`, `def` and `begin` above the keyword.
+      #
       # @example
       #   # bad
       #   if condition
@@ -34,16 +37,17 @@ module RuboCop
       #     y
       #   end
       class CommentedKeyword < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless (match = line(comment).match(/(?<keyword>\S+).*#/))
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
 
-            if offensive?(comment)
-              add_offense(comment, message: format(MSG, keyword: match[:keyword]))
-            end
+            register_offense(comment, match[:keyword])
           end
         end
 
@@ -60,6 +64,19 @@ module RuboCop
         ].freeze
         ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
+        def register_offense(comment, matched_keyword)
+          add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
+            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            corrector.remove(range)
+
+            unless matched_keyword == 'end'
+              corrector.insert_before(
+                range.source_buffer.line_range(comment.loc.line), "#{comment.text}\n"
+              )
+            end
+          end
+        end
+
         def offensive?(comment)
           line = line(comment)
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&

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

@@ -51,6 +51,7 @@ module RuboCop
           if style == :each
             add_offense(node, message: PREFER_EACH) do |corrector|
               ForToEachCorrector.new(node).call(corrector)
+              opposite_style_detected
             end
           else
             correct_style_detected
@@ -63,6 +64,7 @@ module RuboCop
           if style == :for
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
+              opposite_style_detected
             end
           else
             correct_style_detected

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # that can be replaced with `Hash#except` method.
+      #
+      # This cop should only be enabled on Ruby version 3.0 or higher.
+      # (`Hash#except` was added in Ruby 3.0.)
+      #
+      # For safe detection, it is limited to commonly used string and symbol comparisons
+      # when used `==`.
+      # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.except(:bar)
+      #
+      class HashExcept < Base
+        include RangeHelp
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[reject select filter].freeze
+
+        def_node_matcher :bad_method?, <<~PATTERN
+          (block
+            (send _ _)
+            (args
+              (arg _)
+              (arg _))
+            (send
+              _ {:== :!= :eql?} _))
+        PATTERN
+
+        def on_send(node)
+          block = node.parent
+          return unless bad_method?(block) && semantically_except_method?(node, block)
+
+          except_key = except_key(block)
+          return unless safe_to_register_offense?(block, except_key)
+
+          range = offense_range(node)
+          preferred_method = "except(#{except_key.source})"
+
+          add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
+            corrector.replace(range, preferred_method)
+          end
+        end
+
+        private
+
+        def semantically_except_method?(send, block)
+          body = block.body
+
+          case send.method_name
+          when :reject
+            body.method?('==') || body.method?('eql?')
+          when :select, :filter
+            body.method?('!=')
+          else
+            false
+          end
+        end
+
+        def safe_to_register_offense?(block, except_key)
+          return true if block.body.method?('eql?')
+
+          except_key.sym_type? || except_key.str_type?
+        end
+
+        def except_key(node)
+          key_argument = node.argument_list.first
+          lhs, _method_name, rhs = *node.body
+
+          [lhs, rhs].find { |operand| operand.source != key_argument.source }
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,16 @@ module RuboCop
       #     # body omitted
       #   end
       #
+      #   # bad
+      #   do_something do |first: false, second:, third: 10|
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   do_something do |second:, first: false, third: 10|
+      #     # body omitted
+      #   end
+      #
       class KeywordParametersOrder < Base
         include RangeHelp
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
             if node.parent.find(&:kwoptarg_type?) == node
               corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
 
-              arguments = node.each_ancestor(:def, :defs).first.arguments
+              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
               append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
 
               remove_kwargs(kwarg_nodes, corrector)
@@ -50,7 +60,7 @@ module RuboCop
           return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
-          corrector.insert_after(last_kwoptarg, "\n")
+          corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?
         end
 
         def remove_kwargs(kwarg_nodes, corrector)