rubocop 1.6.0 → 1.9.0

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[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

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

@@ -3,9 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks `eval` method usage. `eval` can receive source location
-      # metadata, that are filename and line number. The metadata is used by
-      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      # This cop ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # and `module_eval`) are given filename and line number values (`__FILE__`
+      # and `__LINE__`). This data is used to ensure that any errors raised
+      # within the evaluated code will be given the correct identification
+      # in a backtrace.
+      #
+      # The cop also checks that the line number given relative to `__LINE__` is
+      # correct.
       #
       # @example
       #   # bad
@@ -32,27 +37,17 @@ module RuboCop
       #     end
       #   RUBY
       class EvalWithLocation < Base
-        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
-              'as they are used by backtraces.'
-        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
-                             'as they are used by backtraces.'
+        MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
 
         RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
-        def_node_matcher :eval_without_location?, <<~PATTERN
-          {
-            (send nil? :eval ${str dstr})
-            (send nil? :eval ${str dstr} _)
-            (send nil? :eval ${str dstr} _ #special_file_keyword?)
-            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
-
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr})
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword?)
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword? _)
-          }
+        def_node_matcher :valid_eval_receiver?, <<~PATTERN
+          { nil? (const {nil? cbase} :Kernel) }
         PATTERN
 
         def_node_matcher :line_with_offset?, <<~PATTERN
@@ -63,17 +58,31 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          eval_without_location?(node) do |code|
-            if with_lineno?(node)
-              on_with_lineno(node, code)
-            else
-              add_offense(node)
-            end
+          # Classes should not redefine eval, but in case one does, it shouldn't
+          # register an offense. Only `eval` without a receiver and `Kernel.eval`
+          # are considered.
+          return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
+
+          code = node.arguments.first
+          return unless code.str_type? || code.dstr_type?
+
+          file, line = file_and_line(node)
+
+          if line
+            check_file(node, file)
+            check_line(node, code)
+          else
+            register_offense(node)
           end
         end
 
         private
 
+        def register_offense(node)
+          msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
+          add_offense(node, message: msg)
+        end
+
         def special_file_keyword?(node)
           node.str_type? &&
             node.source == '__FILE__'
@@ -84,6 +93,11 @@ module RuboCop
             node.source == '__LINE__'
         end
 
+        def file_and_line(node)
+          base = node.method?(:eval) ? 2 : 1
+          [node.arguments[base], node.arguments[base + 1]]
+        end
+
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
@@ -95,17 +109,32 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(actual, sign, line_diff)
+        def message_incorrect_line(method_name, actual, sign, line_diff)
           expected =
             if line_diff.zero?
               '__LINE__'
             else
               "__LINE__ #{sign} #{line_diff}"
             end
-          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+
+          format(MSG_INCORRECT_LINE,
+                 method_name: method_name,
+                 actual: actual.source,
+                 expected: expected)
+        end
+
+        def check_file(node, file_node)
+          return true if special_file_keyword?(file_node)
+
+          message = format(MSG_INCORRECT_FILE,
+                           method_name: node.method_name,
+                           expected: '__FILE__',
+                           actual: file_node.source)
+
+          add_offense(file_node, message: message)
         end
 
-        def on_with_lineno(node, code)
+        def check_line(node, code)
           line_node = node.arguments.last
           lineno_range = line_node.loc.expression
           line_diff = string_first_line(code) - lineno_range.first_line
@@ -124,22 +153,22 @@ module RuboCop
           end
         end
 
-        def add_offense_for_same_line(_node, line_node)
+        def add_offense_for_same_line(node, line_node)
           return if special_line_keyword?(line_node)
 
           add_offense(
             line_node.loc.expression,
-            message: message_incorrect_line(line_node, nil, 0)
+            message: message_incorrect_line(node.method_name, line_node, nil, 0)
           )
         end
 
-        def add_offense_for_different_line(_node, line_node, line_diff)
+        def add_offense_for_different_line(node, line_node, line_diff)
           sign = line_diff.positive? ? :+ : :-
           return if line_with_offset?(line_node, sign, line_diff.abs)
 
           add_offense(
             line_node.loc.expression,
-            message: message_incorrect_line(line_node, sign, line_diff.abs)
+            message: message_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
           )
         end
       end

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop enforces the use of explicit block argument to avoid writing
       # block literal that just passes its arguments to another block.
       #
+      # NOTE: This cop only registers an offense if the block args match the
+      # yield args exactly.
+      #
       # @example
       #   # bad
       #   def with_tmp_dir
@@ -75,7 +78,14 @@ module RuboCop
         private
 
         def yielding_arguments?(block_args, yield_args)
+          yield_args = yield_args.dup.fill(
+            nil,
+            yield_args.length, block_args.length - yield_args.length
+          )
+
           yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            next false unless yield_arg && block_arg
+
             block_arg && yield_arg.children.first == block_arg.children.first
           end
         end