rubocop 1.6.0 → 1.9.0

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

@@ -19,6 +19,9 @@ module RuboCop
       #   end
       #
       class MultilineMethodSignature < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Avoid multi-line method signatures.'
 
         def on_def(node)
@@ -26,12 +29,34 @@ module RuboCop
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_defs on_def
 
         private
 
+        def autocorrect(corrector, node)
+          arguments = node.arguments
+          joined_arguments = arguments.map(&:source).join(', ')
+          last_line_source_of_arguments = processed_source[arguments.last_line - 1].strip
+
+          if last_line_source_of_arguments.start_with?(')')
+            joined_arguments = "#{joined_arguments}#{last_line_source_of_arguments}"
+
+            corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
+          end
+
+          corrector.replace(arguments_range(node), joined_arguments)
+        end
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
+          )
+        end
+
         def opening_line(node)
           node.first_line
         end

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

@@ -58,7 +58,9 @@ module RuboCop
         private
 
         def require_then?(when_node)
-          return true if when_node.conditions.count >= 2
+          unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
+            return true
+          end
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line

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

@@ -14,6 +14,8 @@ module RuboCop
       # positives. Luckily, there is no harm in freezing an already
       # frozen object.
       #
+      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+      #
       # @example EnforcedStyle: literals (default)
       #   # bad
       #   CONST = [1, 2, 3]
@@ -94,7 +96,8 @@ module RuboCop
           range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
 
           return unless mutable_literal?(value) ||
-                        range_enclosed_in_parentheses
+                        target_ruby_version <= 2.7 && range_enclosed_in_parentheses
+
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
@@ -119,11 +122,14 @@ module RuboCop
         end
 
         def mutable_literal?(value)
-          value&.mutable_literal?
+          return false if value.nil?
+          return false if frozen_regexp_or_range_literals?(value)
+
+          value.mutable_literal?
         end
 
         def immutable_literal?(node)
-          node.nil? || node.immutable_literal?
+          node.nil? || frozen_regexp_or_range_literals?(node) || node.immutable_literal?
         end
 
         def frozen_string_literal?(node)
@@ -131,6 +137,10 @@ module RuboCop
             frozen_string_literals_enabled?
         end
 
+        def frozen_regexp_or_range_literals?(node)
+          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
+        end
+
         def requires_parentheses?(node)
           node.range_type? ||
             (node.send_type? && node.loc.dot.nil?)

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

@@ -19,6 +19,10 @@ module RuboCop
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return unless node.parenthesized?
 

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

@@ -50,6 +50,7 @@ module RuboCop
                          end
 
               corrector.replace(node, new_code)
+              corrector.wrap(node, '(', ')') if node.parent&.method?(:!)
             end
           end
         end

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

@@ -8,6 +8,9 @@ module RuboCop
       # With `IncludeSemanticChanges` set to `false` by default, this cop
       # does not report offenses for `!x.nil?` and does no changes that might
       # change behavior.
+      # Also `IncludeSemanticChanges` set to `false` with `EnforcedStyle: comparison` of
+      # `Style/NilComparison` cop, this cop does not report offenses for `x != nil` and
+      # does no changes to `!x.nil?` style.
       #
       # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
       # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
@@ -41,6 +44,9 @@ module RuboCop
       class NonNilCheck < Base
         extend AutoCorrector
 
+        MSG_FOR_REPLACEMENT = 'Prefer `%<prefer>s` over `%<current>s`.'
+        MSG_FOR_REDUNDANCY = 'Explicit non-nil checks are usually redundant.'
+
         RESTRICT_ON_SEND = %i[!= nil? !].freeze
 
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
@@ -49,11 +55,12 @@ module RuboCop
         def_node_matcher :not_and_nil_check?, '(send (send _ :nil?) :!)'
 
         def on_send(node)
-          return if ignored_node?(node)
-          return unless (offense_node = find_offense_node(node))
+          return if ignored_node?(node) ||
+                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+          return unless register_offense?(node)
 
           message = message(node)
-          add_offense(offense_node, message: message) do |corrector|
+          add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -73,13 +80,9 @@ module RuboCop
 
         private
 
-        def find_offense_node(node)
-          if not_equal_to_nil?(node)
-            node.loc.selector
-          elsif include_semantic_changes? &&
-                (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            node
-          end
+        def register_offense?(node)
+          not_equal_to_nil?(node) ||
+            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
         end
 
         def autocorrect(corrector, node)
@@ -101,10 +104,11 @@ module RuboCop
         end
 
         def message(node)
-          if node.method?(:!=)
-            'Prefer `!expression.nil?` over `expression != nil`.'
+          if node.method?(:!=) && !include_semantic_changes?
+            prefer = "!#{node.receiver.source}.nil?"
+            format(MSG_FOR_REPLACEMENT, prefer: prefer, current: node.source)
           else
-            'Explicit non-nil checks are usually redundant.'
+            MSG_FOR_REDUNDANCY
           end
         end
 
@@ -138,6 +142,12 @@ module RuboCop
           corrector.replace(node.parent.loc.keyword, 'if')
           corrector.replace(node, receiver.source)
         end
+
+        def nil_comparison_style
+          nil_comparison_conf = config.for_cop('Style/NilComparison')
+
+          nil_comparison_conf['Enabled'] && nil_comparison_conf['EnforcedStyle']
+        end
       end
     end
   end

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

@@ -81,11 +81,12 @@ module RuboCop
           return node.source if message_nodes.size > 1
 
           argument = message_nodes.first.source
+          exception_class = exception_node.const_name || exception_node.receiver.source
 
           if node.parent && requires_parens?(node.parent)
-            "#{node.method_name}(#{exception_node.const_name}.new(#{argument}))"
+            "#{node.method_name}(#{exception_class}.new(#{argument}))"
           else
-            "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
+            "#{node.method_name} #{exception_class}.new(#{argument})"
           end
         end
 
@@ -95,6 +96,7 @@ module RuboCop
               replacement = correction_exploded_to_compact(node)
 
               corrector.replace(node, replacement)
+              opposite_style_detected
             end
           else
             correct_style_detected
@@ -115,6 +117,7 @@ module RuboCop
             replacement = correction_compact_to_exploded(node)
 
             corrector.replace(node, replacement)
+            opposite_style_detected
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # 1. This cop matches for method names only and hence cannot tell apart
       #    methods with same name in different classes.
       # 2. This cop is limited to methods with single parameter.
-      # 3. This cop is unsafe if certain special global variables (e.g. `$;`) are set.
+      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
       #    That depends on the nature of the target methods, of course.
       #
       # Method names and their redundant arguments can be configured like this:
@@ -20,6 +20,8 @@ module RuboCop
       # Methods:
       #   join: ''
       #   split: ' '
+      #   chomp: "\n"
+      #   chomp!: "\n"
       #   foo: 2
       #
       # @example
@@ -28,6 +30,8 @@ module RuboCop
       #   [1, 2, 3].join("")
       #   string.split(" ")
       #   "first\nsecond".split(" ")
+      #   string.chomp("\n")
+      #   string.chomp!("\n")
       #   A.foo(2)
       #
       #   # good
@@ -35,6 +39,8 @@ module RuboCop
       #   [1, 2, 3].join
       #   string.split
       #   "first second".split
+      #   string.chomp
+      #   string.chomp!
       #   A.foo
       class RedundantArgument < Base
         include RangeHelp

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop check for uses of Object#freeze on immutable objects.
+      # This cop check for uses of `Object#freeze` on immutable objects.
+      #
+      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
       # @example
       #   # bad
@@ -37,8 +39,10 @@ module RuboCop
 
           return true if node.immutable_literal?
 
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?
+          return true if FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+                         frozen_string_literals_enabled?
+
+          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
         end
 
         def strip_parenthesis(node)
@@ -52,7 +56,7 @@ module RuboCop
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
-            (begin (send !(str _) {:+ :- :* :** :/ :%} {float int}))
+            (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
             (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)

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

@@ -66,7 +66,7 @@ module RuboCop
         end
 
         def correct_with_arguments(return_node, corrector)
-          if return_node.arguments.size > 1
+          if return_node.children.size > 1
             add_brackets(corrector, return_node)
           elsif hash_without_braces?(return_node.first_argument)
             add_braces(corrector, return_node.first_argument)

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

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks for single-line method definitions that contain a body.
       # It will accept single-line methods with no body.
       #
+      # Endless methods added in Ruby 3.0 are also accepted by this cop.
+      #
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
+      # `allow_always`, single-line methods will be auto-corrected to endless
+      # methods if there is only one statement in the body.
+      #
       # @example
       #   # bad
       #   def some_method; body end
@@ -15,6 +21,7 @@ module RuboCop
       #   # good
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
+      #   def some_method() = body
       #
       # @example AllowIfMethodIsEmpty: true (default)
       #   # good
@@ -32,6 +39,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.single_line?
+          return if node.endless?
           return if allow_empty? && !node.body
 
           add_offense(node) do |corrector|
@@ -43,6 +51,28 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          if correct_to_endless?(node.body)
+            correct_to_endless(corrector, node)
+          else
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
+        end
+
+        def correct_to_endless?(body_node)
+          endless_method_config = config.for_cop('Style/EndlessMethod')
+
+          return false unless endless_method_config['Enabled']
+          return false if endless_method_config['EnforcedStyle'] == 'disallow'
+          return false unless body_node
+
+          !(body_node.begin_type? || body_node.kwbegin_type?)
+        end
+
+        def correct_to_multiline(corrector, node)
           each_part(node.body) do |part|
             LineBreakCorrector.break_line_before(
               range: part, node: node, corrector: corrector,
@@ -58,8 +88,10 @@ module RuboCop
           move_comment(node, corrector)
         end
 
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
+        def correct_to_endless(corrector, node)
+          arguments = node.arguments.any? ? node.arguments.source : '()'
+          replacement = "def #{node.method_name}#{arguments} = #{node.body.source}"
+          corrector.replace(node, replacement)
         end
 
         def each_part(body)

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

@@ -63,13 +63,13 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, if_branch)
+          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
+
           if node.unless?
             corrector.replace(node.loc.keyword, 'if')
             corrector.insert_before(node.condition, '!')
           end
 
-          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
-
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
             correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
@@ -80,8 +80,11 @@ module RuboCop
         end
 
         def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
+          outer_condition = node.condition
+          correct_outer_condition(corrector, outer_condition)
+
           condition = if_branch.condition
-          corrector.insert_after(node.condition, replacement_condition(and_operator, condition))
+          corrector.insert_after(outer_condition, replacement_condition(and_operator, condition))
 
           range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
           corrector.remove(range_with_surrounding_space(range: range, newlines: false))
@@ -100,14 +103,35 @@ module RuboCop
         def correct_for_comment(corrector, node, if_branch)
           return if config.for_cop('Style/IfUnlessModifier')['Enabled']
 
-          comments = processed_source.comments_before_line(if_branch.source_range.line)
+          comments = processed_source.ast_with_comments[if_branch]
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
         end
 
+        def correct_outer_condition(corrector, condition)
+          return unless requrie_parentheses?(condition)
+
+          range = range_between(
+            condition.loc.selector.end_pos, condition.first_argument.source_range.begin_pos
+          )
+
+          corrector.replace(range, '(')
+          corrector.insert_after(condition.last_argument.source_range, ')')
+        end
+
+        def requrie_parentheses?(condition)
+          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized?
+        end
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
+          )
+        end
+
         def wrap_condition?(node)
-          node.or_type? ||
+          node.and_type? || node.or_type? ||
             (node.send_type? && node.arguments.any? && !node.parenthesized?)
         end
 

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

@@ -116,7 +116,7 @@ module RuboCop
             parts.map do |part|
               if part.str_type?
                 if single_quoted?(part)
-                  part.value.gsub('\\') { '\\\\' }
+                  part.value.gsub(/(\\|")/, '\\\\\&')
                 else
                   part.value.inspect[1..-2]
                 end