rubocop 0.78.0 → 1.13.0

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

@@ -35,43 +35,40 @@ module RuboCop
       #   else
       #     puts 'more'
       #   end
-      class EmptyCaseCondition < Cop
+      class EmptyCaseCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Do not use empty `case` condition, instead use an `if` '\
-              'expression.'
+        MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
 
         def on_case(case_node)
           return if case_node.condition
-          return if case_node.when_branches.any? do |when_branch|
-            when_branch.each_descendant.any?(&:return_type?)
-          end
 
-          if (else_branch = case_node.else_branch)
-            return if else_branch.return_type? ||
-                      else_branch.each_descendant.any?(&:return_type?)
+          branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
+
+          return if branch_bodies.any? do |body|
+            body.return_type? ||
+            body.each_descendant.any?(&:return_type?)
           end
 
-          add_offense(case_node, location: :keyword)
+          add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
 
-        def autocorrect(case_node)
+        private
+
+        def autocorrect(corrector, case_node)
           when_branches = case_node.when_branches
 
-          lambda do |corrector|
-            correct_case_when(corrector, case_node, when_branches)
-            correct_when_conditions(corrector, when_branches)
-          end
+          correct_case_when(corrector, case_node, when_branches)
+          correct_when_conditions(corrector, when_branches)
         end
 
-        private
-
         def correct_case_when(corrector, case_node, when_nodes)
           case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
 
           corrector.replace(case_range, 'if')
 
-          keep_first_when_comment(case_node, when_nodes.first, corrector)
+          keep_first_when_comment(case_range, corrector)
 
           when_nodes[1..-1].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
@@ -91,15 +88,14 @@ module RuboCop
           end
         end
 
-        def keep_first_when_comment(case_node, first_when_node, corrector)
-          comment = processed_source.comments_before_line(
-            first_when_node.loc.keyword.line
-          ).map(&:text).join("\n")
-
-          line = range_by_whole_lines(case_node.source_range)
+        def keep_first_when_comment(case_range, corrector)
+          indent = ' ' * case_range.column
+          comments = processed_source.each_comment_in_lines(
+            case_range.first_line...case_range.last_line
+          ).map { |comment| "#{indent}#{comment.text}\n" }.join
 
-          corrector.insert_before(line, "#{comment}\n") if !comment.empty? &&
-                                                           !case_node.parent
+          line_beginning = case_range.adjust(begin_pos: -case_range.column)
+          corrector.insert_before(line_beginning, comments)
         end
       end
     end

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

@@ -89,10 +89,11 @@ module RuboCop
       #   if condition
       #     statement
       #   end
-      class EmptyElse < Cop
+      class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant `else`-clause.'
 
@@ -104,16 +105,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node)
-
-          lambda do |corrector|
-            end_pos = base_node(node).loc.end.begin_pos
-            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
-          end
-        end
-
         private
 
         def check(node)
@@ -132,33 +123,34 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node, location: :else)
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
         def nil_check(node)
           return unless node.else_branch&.nil_type?
 
-          add_offense(node, location: :else)
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
-        def comment_in_else?(node)
-          range = else_line_range(node.loc)
-          processed_source.find_comment { |c| range.include?(c.loc.line) }
+        def autocorrect(corrector, node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+          return false if comment_in_else?(node.loc)
+
+          end_pos = base_node(node).loc.end.begin_pos
+          corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
         end
 
-        def else_line_range(loc)
-          return 0..0 if loc.else.nil? || loc.end.nil?
+        def comment_in_else?(loc)
+          return false if loc.else.nil? || loc.end.nil?
 
-          loc.else.first_line..loc.end.first_line
+          processed_source.contains_comment?(loc.else.join(loc.end))
         end
 
         def base_node(node)
           return node if node.case_type?
           return node unless node.elsif?
 
-          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
-            parent.loc.end
-          end
+          node.each_ancestor(:if, :case, :when).find(-> { node }) { |parent| parent.loc.end }
         end
 
         def autocorrect_forbidden?(type)

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

@@ -16,9 +16,10 @@ module RuboCop
       #
       #   # good
       #   -> (arg) { do_something(arg) }
-      class EmptyLambdaParameter < Cop
+      class EmptyLambdaParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
@@ -29,15 +30,13 @@ module RuboCop
           check(node) if node.send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            send_node = node.parent.send_node
-            range = range_between(
-              send_node.loc.expression.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          send_node = node.parent.send_node
+          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -16,44 +16,57 @@ module RuboCop
       #   a = []
       #   h = {}
       #   s = ''
-      class EmptyLiteral < Cop
+      class EmptyLiteral < Base
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
-        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
-                  '`String.new`.'
+        STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
-        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
-        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
-        def_node_matcher :str_node, '(send (const nil? :String) :new)'
-        def_node_matcher :array_with_block,
-                         '(block (send (const nil? :Array) :new) args _)'
-        def_node_matcher :hash_with_block,
-                         '(block (send (const nil? :Hash) :new) args _)'
+        RESTRICT_ON_SEND = %i[new].freeze
 
-        def on_send(node)
-          add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
-          add_offense(node, message: HASH_MSG) if offense_hash_node?(node)
+        # @!method array_node(node)
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
 
-          str_node(node) do
-            return if frozen_string_literals_enabled?
+        # @!method hash_node(node)
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
 
-            add_offense(node,
-                        message: format(STR_MSG,
-                                        prefer: preferred_string_literal))
-          end
-        end
+        # @!method str_node(node)
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
+
+        # @!method array_with_block(node)
+        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+
+        # @!method hash_with_block(node)
+        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))
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             corrector.replace(replacement_range(node), correction(node))
           end
         end
 
         private
 
+        def offense_message(node)
+          if offense_array_node?(node)
+            ARR_MSG
+          elsif offense_hash_node?(node)
+            HASH_MSG
+          elsif str_node(node) && !frozen_string_literals_enabled?
+            format(STR_MSG, prefer: preferred_string_literal)
+          end
+        end
+
         def preferred_string_literal
           enforce_double_quotes? ? '""' : "''"
         end
@@ -68,24 +81,19 @@ module RuboCop
 
         def first_argument_unparenthesized?(node)
           parent = node.parent
-          unless parent && %i[send super zsuper].include?(parent.type)
-            return false
-          end
+          return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.object_id == parent.arguments.first.object_id &&
-            !parentheses?(node.parent)
+          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
-          if hash_node(node) &&
-             first_argument_unparenthesized?(node)
+          if hash_node(node) && first_argument_unparenthesized?(node)
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].source_range.begin_pos - 1,
-                          args[-1].source_range.end_pos)
+            range_between(args[0].source_range.begin_pos - 1, args[-1].source_range.end_pos)
           else
             node.source_range
           end

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

@@ -8,7 +8,7 @@ module RuboCop
       # line (compact style), but it can be configured to enforce the `end`
       # to go on its own line (expanded style).
       #
-      # Note: A method definition is not considered empty if it contains
+      # NOTE: A method definition is not considered empty if it contains
       #       comments.
       #
       # @example EnforcedStyle: compact (default)
@@ -40,46 +40,39 @@ module RuboCop
       #
       #   def self.foo(bar)
       #   end
-      class EmptyMethod < Cop
+      class EmptyMethod < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'
-        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
-                       'next line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node)
+          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node))
-          end
-        end
-
         private
 
-        def message(_node)
+        def message(_range)
           compact_style? ? MSG_COMPACT : MSG_EXPANDED
         end
 
         def correct_style?(node)
-          compact_style? && compact?(node) ||
-            expanded_style? && expanded?(node)
+          compact_style? && compact?(node) || expanded_style? && expanded?(node)
         end
 
         def corrected(node)
-          if node.arguments?
-            arguments   = node.arguments.source
-            extra_space = ' ' unless parentheses?(node.arguments)
-          end
           scope = node.receiver ? "#{node.receiver.source}." : ''
+          arguments = if node.arguments?
+                        args = node.arguments.map(&:source).join(', ')
 
-          signature = [scope, node.method_name, extra_space, arguments].join
+                        parentheses?(node.arguments) ? "(#{args})" : " #{args}"
+                      end
+          signature = [scope, node.method_name, arguments].join
 
           ["def #{signature}", 'end'].join(joint(node))
         end
@@ -90,10 +83,6 @@ module RuboCop
           compact_style? ? '; ' : "\n#{indent}"
         end
 
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
-        end
-
         def compact?(node)
           node.single_line?
         end

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

@@ -9,27 +9,23 @@ module RuboCop
       #   # encoding: UTF-8
       #   # coding: UTF-8
       #   # -*- coding: UTF-8 -*-
-      class Encoding < Cop
+      class Encoding < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
         SHEBANG = '#!'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.buffer.source.empty?
 
           line_number = encoding_line_number(processed_source)
           return unless (@message = offense(processed_source, line_number))
 
           range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, location: range, message: @message)
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(range: range,
-                                                          side: :right))
+          add_offense(range, message: @message) do |corrector|
+            corrector.remove(range_with_surrounding_space(range: range, side: :right))
           end
         end
 
@@ -42,7 +38,7 @@ module RuboCop
         end
 
         def encoding_omitable?(line)
-          line =~ ENCODING_PATTERN
+          ENCODING_PATTERN.match?(line)
         end
 
         def encoding_line_number(processed_source)

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

@@ -12,12 +12,15 @@ module RuboCop
       #   # good
       #   at_exit { puts 'Goodbye!' }
       #
-      class EndBlock < Cop
-        MSG = 'Avoid the use of `END` blocks. ' \
-              'Use `Kernel#at_exit` instead.'
+      class EndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword) do |corrector|
+            corrector.replace(node.loc.keyword, 'at_exit')
+          end
         end
       end
     end

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

@@ -0,0 +1,101 @@
+# 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) { |corrector| correct_to_multiline(corrector, node) }
+        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