rubocop 1.6.1 → 1.9.1

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

@@ -71,11 +71,7 @@ module RuboCop
           add_offense(range, message: message) do |corrector|
             corrector.replace(range, preferred_name)
 
-            node.body&.each_descendant(:lvar) do |var|
-              next unless var.children.first == offending_name
-
-              corrector.replace(var, preferred_name)
-            end
+            correct_node(corrector, node.body, offending_name, preferred_name)
           end
         end
 
@@ -86,6 +82,43 @@ module RuboCop
           variable.loc.expression
         end
 
+        def variable_name_matches?(node, name)
+          if node.masgn_type?
+            node.each_descendant(:lvasgn).any? do |lvasgn_node|
+              variable_name_matches?(lvasgn_node, name)
+            end
+          else
+            node.children.first == name
+          end
+        end
+
+        def correct_node(corrector, node, offending_name, preferred_name)
+          return unless node
+
+          node.each_node(:lvar, :lvasgn, :masgn) do |child_node|
+            next unless variable_name_matches?(child_node, offending_name)
+
+            corrector.replace(child_node, preferred_name) if child_node.lvar_type?
+
+            if child_node.masgn_type? || child_node.lvasgn_type?
+              correct_reassignment(corrector, child_node, offending_name, preferred_name)
+              break
+            end
+          end
+        end
+
+        # If the exception variable is reassigned, that assignment needs to be corrected.
+        # Further `lvar` nodes will not be corrected though since they now refer to a
+        # different variable.
+        def correct_reassignment(corrector, node, offending_name, preferred_name)
+          if node.lvasgn_type?
+            correct_node(corrector, node.child_nodes.first, offending_name, preferred_name)
+          elsif node.masgn_type?
+            # With multiple assign, the assignments are in an array as the last child
+            correct_node(corrector, node.children.last, offending_name, preferred_name)
+          end
+        end
+
         def preferred_name(variable_name)
           preferred_name = cop_config.fetch('PreferredName', 'e')
           if variable_name.to_s.start_with?('_')

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

@@ -20,6 +20,7 @@ module RuboCop
       #   # good
       #   fooBar = 1
       class VariableName < Base
+        include AllowedIdentifiers
         include ConfigurableNaming
 
         MSG = 'Use %<style>s for variable names.'
@@ -27,6 +28,7 @@ module RuboCop
         def on_lvasgn(node)
           name, = *node
           return unless name
+          return if allowed_identifier?(name)
 
           check_name(node, name, node.loc.name)
         end

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

@@ -92,11 +92,12 @@ module RuboCop
       #   # good
       #   :some_sym_1
       #
-      # @example AllowedIdentifier: [capture3]
+      # @example AllowedIdentifiers: [capture3]
       #   # good
       #   expect(Open3).to receive(:capture3)
       #
       class VariableNumber < Base
+        include AllowedIdentifiers
         include ConfigurableNumbering
 
         MSG = 'Use %<style>s for %<identifier_type>s numbers.'
@@ -139,14 +140,6 @@ module RuboCop
 
           format(MSG, style: style, identifier_type: identifier_type)
         end
-
-        def allowed_identifier?(name)
-          allowed_identifiers.include?(name.to_s.delete('@'))
-        end
-
-        def allowed_identifiers
-          cop_config.fetch('AllowedIdentifiers', [])
-        end
       end
     end
   end

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/severity.rb

@@ -6,10 +6,10 @@ module RuboCop
     class Severity
       include Comparable
 
-      NAMES = %i[refactor convention warning error fatal].freeze
+      NAMES = %i[info refactor convention warning error fatal].freeze
 
       # @api private
-      CODE_TABLE = { R: :refactor, C: :convention,
+      CODE_TABLE = { I: :info, R: :refactor, C: :convention,
                      W: :warning, E: :error, F: :fatal }.freeze
 
       # @api public
@@ -18,7 +18,7 @@ module RuboCop
       #
       # @return [Symbol]
       #   severity.
-      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
       def self.name_from_code(code)

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/ascii_comments.rb

@@ -7,7 +7,7 @@ module RuboCop
     module Style
       # This cop checks for non-ascii (non-English) characters
       # in comments. You could set an array of allowed non-ascii chars in
-      # AllowedChars attribute (empty by default).
+      # `AllowedChars` attribute (copyright notice "©" by default).
       #
       # @example
       #   # bad

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/disable_cops_within_source_code_directive.rb

@@ -9,37 +9,77 @@ module RuboCop
       # This is useful if want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
+      # Specific cops can be allowed with the `AllowedCops` configuration. Note that
+      # if this configuration is set, `rubocop:disable all` is still disallowed.
+      #
       # @example
       #   # bad
       #   # rubocop:disable Metrics/AbcSize
-      #   def f
+      #   def foo
       #   end
       #   # rubocop:enable Metrics/AbcSize
       #
       #   # good
-      #   def fixed_method_name_and_no_rubocop_comments
+      #   def foo
+      #   end
+      #
+      # @example AllowedCops: [Metrics/AbcSize]
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   def foo
       #   end
+      #   # rubocop:enable Metrics/AbcSize
       #
       class DisableCopsWithinSourceCodeDirective < Base
         extend AutoCorrector
 
         # rubocop:enable Lint/RedundantCopDisableDirective
-        MSG = 'Comment to disable/enable RuboCop.'
+        MSG = 'Rubocop disable/enable directives are not permitted.'
+        MSG_FOR_COPS = 'Rubocop disable/enable directives for %<cops>s are not permitted.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless rubocop_directive_comment?(comment)
+            directive_cops = directive_cops(comment)
+            disallowed_cops = directive_cops - allowed_cops
 
-            add_offense(comment) do |corrector|
-              corrector.replace(comment, '')
-            end
+            next unless disallowed_cops.any?
+
+            register_offense(comment, directive_cops, disallowed_cops)
           end
         end
 
         private
 
-        def rubocop_directive_comment?(comment)
-          CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
+        def register_offense(comment, directive_cops, disallowed_cops)
+          message = if any_cops_allowed?
+                      format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
+                    else
+                      MSG
+                    end
+
+          add_offense(comment, message: message) do |corrector|
+            replacement = ''
+
+            if directive_cops.length != disallowed_cops.length
+              replacement = comment.text.sub(/#{Regexp.union(disallowed_cops)},?\s*/, '')
+                                   .sub(/,\s*$/, '')
+            end
+
+            corrector.replace(comment, replacement)
+          end
+        end
+
+        def directive_cops(comment)
+          match = CommentConfig::COMMENT_DIRECTIVE_REGEXP.match(comment.text)
+          match && match[2] ? match[2].split(',').map(&:strip) : []
+        end
+
+        def allowed_cops
+          Array(cop_config['AllowedCops'])
+        end
+
+        def any_cops_allowed?
+          allowed_cops.any?
         end
       end
     end

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

@@ -32,8 +32,12 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
                          '(block (send (const {nil? cbase} :Array) :new) args _)'
-        def_node_matcher :hash_with_block,
-                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
+        def_node_matcher :hash_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Hash) :new) args _)
+            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+          }
+        PATTERN
 
         def on_send(node)
           return unless (message = offense_message(node))

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for endless methods.
+      #
+      # It can enforce either the use of endless methods definitions
+      # for single-lined method bodies, or disallow endless methods.
+      #
+      # Other method definition types are not considered by this cop.
+      #
+      # The supported styles are:
+      # * allow_single_line (default) - only single line endless method definitions are allowed.
+      # * allow_always - all endless method definitions are allowed.
+      # * disallow - all endless method definitions are disallowed.
+      #
+      # NOTE: Incorrect endless method definitions will always be
+      # corrected to a multi-line definition.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # good
+      #   def my_method() = x
+      #
+      #   # bad, multi-line endless method
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      # @example EnforcedStyle: allow_always
+      #   # good
+      #   def my_method() = x
+      #
+      #   # good
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   def my_method; x end
+      #
+      #   # bad
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      class EndlessMethod < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        CORRECTION_STYLES = %w[multiline single_line].freeze
+        MSG = 'Avoid endless method definitions.'
+        MSG_MULTI_LINE = 'Avoid endless method definitions with multiple lines.'
+
+        def on_def(node)
+          if style == :disallow
+            handle_disallow_style(node)
+          else
+            handle_allow_style(node)
+          end
+        end
+
+        private
+
+        def handle_allow_style(node)
+          return unless node.endless?
+          return if node.single_line? || style == :allow_always
+
+          add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def handle_disallow_style(node)
+          return unless node.endless?
+
+          add_offense(node) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def correct_to_multiline(corrector, node)
+          replacement = <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)}
+              #{node.body.source}
+            end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+
+        def arguments(node, missing = '')
+          node.arguments.any? ? node.arguments.source : missing
+        end
+      end
+    end
+  end
+end