rubocop 1.5.0 → 1.7.0

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

@@ -95,6 +95,7 @@ module RuboCop
               replacement = correction_exploded_to_compact(node)
 
               corrector.replace(node, replacement)
+              opposite_style_detected
             end
           else
             correct_style_detected
@@ -115,6 +116,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} ...)

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

@@ -80,14 +80,30 @@ module RuboCop
           delimiters.include?(char)
         end
 
-        def each_escape(node)
-          node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
-
-            if expr.type == :set
-              char_class_depth + (event == :enter ? 1 : -1)
-            else
-              char_class_depth
+        if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
+          def each_escape(node)
+            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+              yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+
+              if expr.type == :set
+                char_class_depth + (event == :enter ? 1 : -1)
+              else
+                char_class_depth
+              end
+            end
+          end
+        # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
+        # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+        else
+          def each_escape(node)
+            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+              yield(expr.text[1], expr.start_index, !char_class_depth.zero?) if expr.type == :escape
+
+              if expr.type == :set
+                char_class_depth + (event == :enter ? 1 : -1)
+              else
+                char_class_depth
+              end
             end
           end
         end

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

@@ -29,6 +29,8 @@ module RuboCop
       #     c + d
       #   end
       class SingleLineBlockParams < Base
+        extend AutoCorrector
+
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
         def on_block(node)
@@ -37,20 +39,41 @@ module RuboCop
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          return if args_match?(node.send_node.method_name, node.arguments)
+          method_name = node.send_node.method_name
+          return if args_match?(method_name, node.arguments)
+
+          preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
+          joined_block_arguments = preferred_block_arguments.values.join(', ')
 
-          message = message(node.arguments)
+          message = format(MSG, method: method_name, params: joined_block_arguments)
 
-          add_offense(node.arguments, message: message)
+          add_offense(node.arguments, message: message) do |corrector|
+            autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          end
         end
 
         private
 
-        def message(node)
-          method_name = node.parent.send_node.method_name
-          arguments   = target_args(method_name).join(', ')
+        def build_preferred_arguments_map(node, preferred_arguments)
+          preferred_arguments_map = {}
+          node.arguments.each_with_index do |current_lvar, index|
+            preferred_argument = preferred_arguments[index]
+            current_argument = current_lvar.source
+            preferred_argument = "_#{preferred_argument}" if current_argument.start_with?('_')
+            preferred_arguments_map[current_argument] = preferred_argument
+          end
+
+          preferred_arguments_map
+        end
+
+        def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          corrector.replace(node.arguments, "|#{joined_block_arguments}|")
 
-          format(MSG, method: method_name, params: arguments)
+          node.each_descendant(:lvar) do |lvar|
+            if (preferred_lvar = preferred_block_arguments[lvar.source])
+              corrector.replace(lvar, preferred_lvar)
+            end
+          end
         end
 
         def eligible_arguments?(node)

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

@@ -6,6 +6,8 @@ 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.
+      #
       # @example
       #   # bad
       #   def some_method; body end
@@ -15,6 +17,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 +35,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|

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

@@ -68,22 +68,22 @@ module RuboCop
             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_gurad_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
           else
             correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_comment(corrector, node, if_branch)
           end
-
-          correct_for_comment(corrector, node, if_branch)
         end
 
-        def correct_for_gurad_condition_style(corrector, node, if_branch, and_operator)
-          corrector.insert_after(node.condition, "#{and_operator}#{if_branch.condition.source}")
+        def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
+          condition = if_branch.condition
+          corrector.insert_after(node.condition, replacement_condition(and_operator, condition))
 
-          range = range_between(
-            if_branch.loc.keyword.begin_pos, if_branch.condition.source_range.end_pos
-          )
+          range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
           corrector.remove(range_with_surrounding_space(range: range, newlines: false))
           corrector.remove(if_branch.loc.keyword)
         end
@@ -94,15 +94,31 @@ module RuboCop
           )
           corrector.replace(range, and_operator)
           corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+          corrector.wrap(if_branch.condition, '(', ')') if wrap_condition?(if_branch.condition)
         end
 
         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)
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
         end
 
+        def wrap_condition?(node)
+          node.or_type? ||
+            (node.send_type? && node.arguments.any? && !node.parenthesized?)
+        end
+
+        def replacement_condition(and_operator, condition)
+          if wrap_condition?(condition)
+            "#{and_operator}(#{condition.source})"
+          else
+            "#{and_operator}#{condition.source}"
+          end
+        end
+
         def allow_modifier?
           cop_config['AllowModifier']
         end

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

@@ -26,10 +26,6 @@ module RuboCop
       #   puts $LAST_MATCH_INFO
       #   puts $IGNORECASE
       #   puts $ARGV # or ARGV
-      #   puts $MATCH
-      #   puts $PREMATCH
-      #   puts $POSTMATCH
-      #   puts $LAST_PAREN_MATCH
       #
       # @example EnforcedStyle: use_perl_names
       #   # good
@@ -51,10 +47,6 @@ module RuboCop
       #   puts $~
       #   puts $=
       #   puts $*
-      #   puts $&
-      #   puts $`
-      #   puts $'
-      #   puts $+
       #
       class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
@@ -85,11 +77,7 @@ module RuboCop
           :$? => [:$CHILD_STATUS],
           :$~ => [:$LAST_MATCH_INFO],
           :$= => [:$IGNORECASE],
-          :$* => %i[$ARGV ARGV],
-          :$& => [:$MATCH],
-          :$` => [:$PREMATCH],
-          :$' => [:$POSTMATCH],
-          :$+ => [:$LAST_PAREN_MATCH]
+          :$* => %i[$ARGV ARGV]
         }
 
         PERL_VARS =

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

@@ -11,6 +11,10 @@ module RuboCop
       # In those cases, it might be useful to extract statements to local
       # variables or methods which you can then interpolate in a string.
       #
+      # NOTE: When concatenation between two strings is broken over multiple
+      # lines, this cop does not register an offense; instead,
+      # `Style/LineEndConcatenation` will pick up the offense if enabled.
+      #
       # @example
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
@@ -19,6 +23,10 @@ module RuboCop
       #   email_with_name = "#{user.name} <#{user.email}>"
       #   email_with_name = format('%s <%s>', user.name, user.email)
       #
+      #   # accepted, line-end concatenation
+      #   name = 'First' +
+      #     'Last'
+      #
       class StringConcatenation < Base
         include Util
         extend AutoCorrector
@@ -39,6 +47,7 @@ module RuboCop
 
         def on_send(node)
           return unless string_concatenation?(node)
+          return if line_end_concatenation?(node)
 
           topmost_plus_node = find_topmost_plus_node(node)
 
@@ -58,6 +67,16 @@ module RuboCop
 
         private
 
+        def line_end_concatenation?(node)
+          # If the concatenation happens at the end of the line,
+          # and both the receiver and argument are strings, allow
+          # `Style/LineEndConcatenation` to handle it instead.
+          node.receiver.str_type? &&
+            node.first_argument.str_type? &&
+            node.multiline? &&
+            node.source =~ /\+\s*\n/
+        end
+
         def find_topmost_plus_node(node)
           current = node
           while (parent = current.parent) && plus_node?(parent)
@@ -106,7 +125,13 @@ module RuboCop
               end
             end
 
-          "\"#{interpolated_parts.join}\""
+          "\"#{handle_quotes(interpolated_parts).join}\""
+        end
+
+        def handle_quotes(parts)
+          parts.map do |part|
+            part == '"' ? '\"' : part
+          end
         end
 
         def single_quoted?(str_node)

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

@@ -26,9 +26,10 @@ module RuboCop
       #   "Just some text"
       #   "No special chars or interpolation"
       #   "Every string in #{project} uses double_quotes"
-      class StringLiterals < Cop
+      class StringLiterals < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        extend AutoCorrector
 
         MSG_INCONSISTENT = 'Inconsistent quote style.'
 
@@ -46,7 +47,7 @@ module RuboCop
           quote_styles = detect_quote_styles(node)
 
           if quote_styles.size > 1
-            add_offense(node, message: MSG_INCONSISTENT)
+            register_offense(node, message: MSG_INCONSISTENT)
           else
             check_multiline_quote_style(node, quote_styles[0])
           end
@@ -54,11 +55,17 @@ module RuboCop
           ignore_node(node)
         end
 
-        def autocorrect(node)
-          StringLiteralCorrector.correct(node, style)
+        private
+
+        def autocorrect(corrector, node)
+          StringLiteralCorrector.correct(corrector, node, style)
         end
 
-        private
+        def register_offense(node, message: nil)
+          add_offense(node, message: message || message(node)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
 
         def all_string_literals?(nodes)
           nodes.all? { |n| n.str_type? || n.dstr_type? }
@@ -99,14 +106,13 @@ module RuboCop
         end
 
         def check_multiline_quote_style(node, quote)
-          range = node.source_range
           children = node.children
           if unexpected_single_quotes?(quote)
             all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
-            add_offense(node, location: range) if all_children_with_quotes
+            register_offense(node) if all_children_with_quotes
           elsif unexpected_double_quotes?(quote) &&
                 !accept_child_double_quotes?(children)
-            add_offense(node, location: range)
+            register_offense(node)
           end
         end