rubocop 1.6.1 → 1.9.1

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

@@ -50,6 +50,9 @@ module RuboCop
                          end
 
               corrector.replace(node, new_code)
+
+              parent = node.parent
+              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && 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/numeric_literals.rb

@@ -28,10 +28,6 @@ module RuboCop
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Base
-        # The parameter is called MinDigits (meaning the minimum number of
-        # digits for which an offense can be registered), but essentially it's
-        # a Max parameter (the maximum number of something that's allowed).
-        include ConfigurableMax
         include IntegerNode
         extend AutoCorrector
 
@@ -39,6 +35,11 @@ module RuboCop
               'separate every 3 digits with them.'
         DELIMITER_REGEXP = /[eE.]/.freeze
 
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offense can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        exclude_limit 'MinDigits'
+
         def on_int(node)
           check(node)
         end
@@ -49,10 +50,6 @@ module RuboCop
 
         private
 
-        def max_parameter_name
-          'MinDigits'
-        end
-
         def check(node)
           int = integer_part(node)
 
@@ -62,7 +59,7 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.max = int.size + 1)
+            return unless (self.min_digits = int.size + 1)
 
             register_offense(node)
           when /\d{4}/, short_group_regex

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

@@ -8,7 +8,7 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
+      # The cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #

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