rubocop 1.5.1 → 1.8.0

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

@@ -68,7 +68,8 @@ module RuboCop
           length = cop_config['MinBranchesCount'] || 3
           return length if length.is_a?(Integer) && length.positive?
 
-          raise 'MinBranchesCount needs to be a positive integer!'
+          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
+          exit!
         end
       end
     end

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

@@ -82,12 +82,10 @@ module RuboCop
         def autocorrect(corrector, node)
           if node.modifier_form?
             correct_to_elsif_from_modifier_form(corrector, node)
-            end_range = node.parent.loc.end
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
-            end_range = node.loc.end
           end
-          corrector.remove(range_by_whole_lines(end_range, include_final_newline: true))
+          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
           corrector.remove(
             range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
           )
@@ -110,6 +108,13 @@ module RuboCop
           corrector.remove(condition)
         end
 
+        def find_end_range(node)
+          end_range = node.loc.end
+          return end_range if end_range
+
+          find_end_range(node.parent)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -46,6 +46,10 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
         def on_if(node)
           msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
                   MSG_USE_MODIFIER

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

@@ -18,7 +18,7 @@ module RuboCop
       #
       #   # good
       #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
-      class IpAddresses < Cop
+      class IpAddresses < Base
         include StringHelp
 
         IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest

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

@@ -21,6 +21,16 @@ module RuboCop
       #     # body omitted
       #   end
       #
+      #   # bad
+      #   do_something do |first: false, second:, third: 10|
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   do_something do |second:, first: false, third: 10|
+      #     # body omitted
+      #   end
+      #
       class KeywordParametersOrder < Base
         include RangeHelp
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
             if node.parent.find(&:kwoptarg_type?) == node
               corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
 
-              arguments = node.each_ancestor(:def, :defs).first.arguments
+              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
               append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
 
               remove_kwargs(kwarg_nodes, corrector)
@@ -50,7 +60,7 @@ module RuboCop
           return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
-          corrector.insert_after(last_kwoptarg, "\n")
+          corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?
         end
 
         def remove_kwargs(kwarg_nodes, corrector)

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