rubocop 1.5.2 → 1.8.1

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

@@ -27,8 +27,9 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
 
-          if offense?(node) && opposite_style_detected
+          if offense?(node)
             add_offense(node) do |corrector|
+              opposite_style_detected
               autocorrect(corrector, node)
             end
           else

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

@@ -40,6 +40,9 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
+      # NOTE: Parens are required around a method with arguments when inside an
+      # endless method definition (>= Ruby 3.0).
+      #
       # @example EnforcedStyle: require_parentheses (default)
       #
       #   # bad
@@ -154,6 +157,10 @@ module RuboCop
         include OmitParentheses
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::NestedParenthesizedCalls]
+        end
+
         def on_send(node)
           send(style, node) # call require_parentheses or omit_parentheses
         end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -14,25 +14,35 @@ module RuboCop
 
           def omit_parentheses(node)
             return unless node.parenthesized?
+            return if inside_endless_method_def?(node)
             return if node.implicit_call?
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              if parentheses_at_the_end_of_multiline_call?(node)
-                corrector.replace(args_begin(node), ' \\')
-              else
-                corrector.replace(args_begin(node), ' ')
-              end
-              corrector.remove(node.loc.end)
+              auto_correct(corrector, node)
+            end
+          end
+
+          def auto_correct(corrector, node)
+            if parentheses_at_the_end_of_multiline_call?(node)
+              corrector.replace(args_begin(node), ' \\')
+            else
+              corrector.replace(args_begin(node), ' ')
             end
+            corrector.remove(node.loc.end)
           end
 
           def offense_range(node)
             node.loc.begin.join(node.loc.end)
           end
 
+          def inside_endless_method_def?(node)
+            # parens are required around arguments inside an endless method
+            node.each_ancestor(:def).any?(&:endless?) && node.arguments.any?
+          end
+
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
       #
+      # This cop does not consider endless methods, since parentheses are
+      # always required for them.
+      #
       # @example EnforcedStyle: require_parentheses (default)
       #   # The `require_parentheses` style requires method definitions
       #   # to always use parentheses
@@ -94,6 +97,8 @@ module RuboCop
                       'parameters.'
 
         def on_def(node)
+          return if node.endless?
+
           args = node.arguments
 
           if require_parentheses?(args)
@@ -142,6 +147,7 @@ module RuboCop
 
           add_offense(location, message: MSG_MISSING) do |corrector|
             correct_definition(node, corrector)
+            unexpected_style_detected 'require_no_parentheses'
           end
         end
 
@@ -149,6 +155,7 @@ module RuboCop
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted
             correct_arguments(args, corrector)
+            unexpected_style_detected 'require_parentheses'
           end
         end
       end

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of Perl-style regexp match
-      # backreferences like $1, $2, etc.
+      # backreferences and their English versions like
+      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -15,19 +16,95 @@ module RuboCop
       class PerlBackrefs < Base
         extend AutoCorrector
 
-        MSG = 'Avoid the use of Perl-style backrefs.'
+        MESSAGE_FORMAT = 'Prefer `%<preferred_expression>s` over `%<original_expression>s`.'
+
+        def on_back_ref(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        def on_gvar(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
 
         def on_nth_ref(node)
-          add_offense(node) do |corrector|
-            backref, = *node
-            parent_type = node.parent ? node.parent.type : nil
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
 
-            if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node, "{Regexp.last_match(#{backref})}")
+        private
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def derived_from_braceless_interpolation?(node)
+          %i[
+            dstr
+            regexp
+            xstr
+          ].include?(node.parent&.type)
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @param [String] preferred_expression
+        # @return [String]
+        def format_message(node:, preferred_expression:)
+          original_expression = original_expression_of(node)
+          format(
+            MESSAGE_FORMAT,
+            original_expression: original_expression,
+            preferred_expression: preferred_expression
+          )
+        end
 
-            else
-              corrector.replace(node, "Regexp.last_match(#{backref})")
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def original_expression_of(node)
+          first = node.to_a.first
+          if first.is_a?(::Integer)
+            "$#{first}"
+          else
+            first.to_s
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to(node)
+          first = node.to_a.first
+          case first
+          when ::Integer
+            "Regexp.last_match(#{first})"
+          when :$&, :$MATCH
+            'Regexp.last_match(0)'
+          when :$`, :$PREMATCH
+            'Regexp.last_match.pre_match'
+          when :$', :$POSTMATCH
+            'Regexp.last_match.post_match'
+          when :$+, :$LAST_PAREN_MATCH
+            'Regexp.last_match(-1)'
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        def on_back_ref_or_gvar_or_nth_ref(node)
+          preferred_expression = preferred_expression_to(node)
+          return unless preferred_expression
+
+          add_offense(
+            node,
+            message: format_message(
+              node: node,
+              preferred_expression: preferred_expression
+            )
+          ) do |corrector|
+            if derived_from_braceless_interpolation?(node)
+              preferred_expression = "{#{preferred_expression}}"
             end
+
+            corrector.replace(node, preferred_expression)
           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,8 +39,13 @@ module RuboCop
       #   [1, 2, 3].join
       #   string.split
       #   "first second".split
+      #   string.chomp
+      #   string.chomp!
       #   A.foo
       class RedundantArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Argument %<arg>s is redundant because it is implied by default.'
 
         def on_send(node)
@@ -44,7 +53,9 @@ module RuboCop
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
-          add_offense(node, message: format(MSG, arg: node.arguments.first.source))
+          add_offense(node, message: format(MSG, arg: node.arguments.first.source)) do |corrector|
+            corrector.remove(argument_range(node))
+          end
         end
 
         private
@@ -69,6 +80,14 @@ module RuboCop
               Parser::CurrentRuby.new(builder).parse(buffer)
             end
         end
+
+        def argument_range(node)
+          if node.parenthesized?
+            range_between(node.loc.begin.begin_pos, node.loc.end.end_pos)
+          else
+            range_with_surrounding_space(range: node.first_argument.source_range, newlines: false)
+          end
+        end
       end
     end
   end

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} ...)