rubocop 1.18.3 → 1.19.0

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

@@ -36,13 +36,7 @@ module RuboCop
             next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
 
             add_offense(comment) do |corrector|
-              prefix = if comment.text.start_with?('# rubocop:disable')
-                         '# rubocop:disable'
-                       else
-                         '# rubocop:todo'
-                       end
-
-              corrector.replace(comment, comment.text[/#{prefix} \S+/])
+              corrector.replace(comment, comment.text.gsub(%r{ # rubocop:(disable|todo)}, ','))
             end
           end
         end

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

@@ -43,7 +43,7 @@ module RuboCop
       #   RUBY
       #
       # This cop works only when a string literal is given as a code string.
-      # No offence is reported if a string variable is given as below:
+      # No offense is reported if a string variable is given as below:
       #
       # @example
       #   # not checked

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

@@ -93,18 +93,43 @@ module RuboCop
 
         def add_block_argument(node, corrector)
           if node.arguments?
-            last_arg = node.arguments.last
-            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-            replacement = ' &block'
-            replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
-            corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
-          elsif node.call_type? || node.zsuper_type?
-            corrector.insert_after(node, '(&block)')
+            insert_argument(node, corrector)
+          elsif empty_arguments?(node)
+            corrector.replace(node.arguments, '(&block)')
+          elsif call_like?(node)
+            correct_call_node(node, corrector)
           else
             corrector.insert_after(node.loc.name, '(&block)')
           end
         end
 
+        def empty_arguments?(node)
+          # Is there an arguments node with only parentheses?
+          node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
+        end
+
+        def call_like?(node)
+          node.call_type? || node.zsuper_type? || node.super_type?
+        end
+
+        def insert_argument(node, corrector)
+          last_arg = node.arguments.last
+          arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+          replacement = ' &block'
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+        end
+
+        def correct_call_node(node, corrector)
+          corrector.insert_after(node, '(&block)')
+          return unless node.parenthesized?
+
+          args_begin = Util.args_begin(node)
+          args_end = Util.args_end(node)
+          range = range_between(args_begin.begin_pos, args_end.end_pos)
+          corrector.remove(range)
+        end
+
         def block_body_range(block_node, send_node)
           range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
         end

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

@@ -27,11 +27,8 @@ module RuboCop
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
       class HashTransformKeys < Base
         include HashTransformMethod
-        extend TargetRubyVersion
         extend AutoCorrector
 
-        minimum_target_ruby_version 2.5
-
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block

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

@@ -7,6 +7,22 @@ module RuboCop
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
+      # This cop is marked unsafe auto-correction as the order of method invocations
+      # must be guaranteed in the following case:
+      #
+      # [source,ruby]
+      # ----
+      # if method_that_modifies_global_state # 1
+      #   method_that_relies_on_global_state # 2
+      #   foo                                # 3
+      # else
+      #   method_that_relies_on_global_state # 2
+      #   bar                                # 3
+      # end
+      # ----
+      #
+      # In such a case, auto-correction may change the invocation order.
+      #
       # NOTE: The cop is poorly named and some people might think that it actually
       # checks for duplicated conditional branches. The name will probably be changed
       # in a future major RuboCop release.
@@ -124,21 +140,30 @@ module RuboCop
           return if branches.any?(&:nil?)
 
           tails = branches.map { |branch| tail(branch) }
-          check_expressions(node, tails, :after_condition) if duplicated_expressions?(tails)
+          check_expressions(node, tails, :after_condition) if duplicated_expressions?(node, tails)
 
           heads = branches.map { |branch| head(branch) }
-          check_expressions(node, heads, :before_condition) if duplicated_expressions?(heads)
+          check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
         end
 
-        def duplicated_expressions?(expressions)
-          expressions.size > 1 && expressions.uniq.one?
+        def duplicated_expressions?(node, expressions)
+          unique_expressions = expressions.uniq
+          return false unless expressions.size >= 1 && unique_expressions.one?
+
+          unique_expression = unique_expressions.first
+          return true unless unique_expression.assignment?
+
+          lhs = unique_expression.child_nodes.first
+          node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
-        def check_expressions(node, expressions, insert_position)
+        def check_expressions(node, expressions, insert_position) # rubocop:disable Metrics/MethodLength
           inserted_expression = false
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
+              next if node.if_type? && node.ternary?
+
               range = range_by_whole_lines(expression.source_range, include_final_newline: true)
               corrector.remove(range)
               next if inserted_expression

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

@@ -96,7 +96,7 @@ module RuboCop
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
         def on_def(node)
-          return if node.endless?
+          return if forced_parentheses?(node)
 
           args = node.arguments
 
@@ -129,6 +129,15 @@ module RuboCop
           corrector.insert_after(arguments_range, ')')
         end
 
+        def forced_parentheses?(node)
+          # Regardless of style, parentheses are necessary for:
+          # 1. Endless methods
+          # 2. Argument lists containing a `forward-arg` (`...`)
+          # Removing the parens would be a syntax error here.
+
+          node.endless? || node.arguments.any?(&:forward_arg_type?)
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline && args.multiline?)

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Checks for `if` expressions that do not have an `else` branch.
       #
+      # NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`,
+      # it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`.
+      #
       # Supported styles are: if, case, both.
       #
       # @example EnforcedStyle: if
@@ -114,6 +117,10 @@ module RuboCop
           check(node)
         end
 
+        def on_case_match(node)
+          # do nothing.
+        end
+
         private
 
         def check(node)

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

@@ -61,13 +61,12 @@ module RuboCop
 
         def on_casgn(node)
           _scope, _const_name, value = *node
-          on_assignment(value)
-        end
+          if value.nil? # This is only the case for `CONST += ...` or similarg66
+            parent = node.parent
+            return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
-        def on_or_asgn(node)
-          lhs, value = *node
-
-          return unless lhs&.casgn_type?
+            value = parent.children.last
+          end
 
           on_assignment(value)
         end
@@ -118,14 +117,13 @@ module RuboCop
         end
 
         def mutable_literal?(value)
-          return false if value.nil?
           return false if frozen_regexp_or_range_literals?(value)
 
           value.mutable_literal?
         end
 
         def immutable_literal?(node)
-          node.nil? || frozen_regexp_or_range_literals?(node) || node.immutable_literal?
+          frozen_regexp_or_range_literals?(node) || node.immutable_literal?
         end
 
         def frozen_string_literal?(node)

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where conditional branch makes redundant self-assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo = condition ? bar : foo
+      #
+      #   # good
+      #   foo = bar if condition
+      #
+      #   # bad
+      #   foo = condition ? foo : bar
+      #
+      #   # good
+      #   foo = bar unless condition
+      #
+      class RedundantSelfAssignmentBranch < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the self-assignment branch.'
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send nil? :bad_method ...)
+        PATTERN
+
+        def on_lvasgn(node)
+          variable, expression = *node
+          return unless expression&.if_type?
+          return unless expression.ternary? || expression.else?
+
+          if_branch = expression.if_branch
+          else_branch = expression.else_branch
+
+          if self_assign?(variable, if_branch)
+            register_offense(expression, if_branch, else_branch, 'unless')
+          elsif self_assign?(variable, else_branch)
+            register_offense(expression, else_branch, if_branch, 'if')
+          end
+        end
+
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        private
+
+        def self_assign?(variable, branch)
+          variable.to_s == branch&.source
+        end
+
+        def register_offense(if_node, offense_branch, opposite_branch, keyword)
+          add_offense(offense_branch) do |corrector|
+            if if_node.ternary?
+              replacement = "#{opposite_branch.source} #{keyword} #{if_node.condition.source}"
+              corrector.replace(if_node, replacement)
+            else
+              if_node_loc = if_node.loc
+
+              range = range_by_whole_lines(offense_branch.source_range, include_final_newline: true)
+              corrector.remove(range)
+              range = range_by_whole_lines(if_node_loc.else, include_final_newline: true)
+              corrector.remove(range)
+
+              autocorrect_if_condition(corrector, if_node, if_node_loc, keyword)
+            end
+          end
+        end
+
+        def autocorrect_if_condition(corrector, if_node, if_node_loc, keyword)
+          else_branch = if_node.else_branch
+
+          if else_branch.respond_to?(:elsif?) && else_branch.elsif?
+            corrector.replace(if_node.condition, else_branch.condition.source)
+          else
+            corrector.replace(if_node_loc.keyword, keyword)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -60,8 +60,8 @@ module RuboCop
         # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
-            (send $(send _ $:sort ...) ${:last :first})
-            (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
+            (send $(send _ $:sort) ${:last :first})
+            (send $(send _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
 
             (send $(send _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})

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

@@ -32,38 +32,29 @@ module RuboCop
 
         MSG = 'Do not use semicolons to terminate expressions.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SingleLineMethods]
+        end
+
         def on_new_investigation
           return if processed_source.blank?
 
-          @processed_source = processed_source
-
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
+        def on_begin(node)
           return if cop_config['AllowAsExpressionSeparator']
 
           exprs = node.children
 
           return if exprs.size < 2
 
-          # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
-          lines = exprs_lines.group_by(&:itself)
-
-          lines.each do |line, expr_on_line|
+          expressions_per_line(exprs).each do |line, expr_on_line|
             # Every line with more than one expression on it is a
             # potential offense
             next unless expr_on_line.size > 1
 
-            # TODO: Find the correct position of the semicolon. We don't know
-            # if the first semicolon on the line is a separator of
-            # expressions. It's just a guess.
-            column = @processed_source[line - 1].index(';')
-
-            next unless column
-
-            convention_on(line, column, false)
+            find_semicolon_positions(line) { |pos| register_semicolon(line, pos, true) }
           end
         end
 
@@ -71,9 +62,9 @@ module RuboCop
 
         def check_for_line_terminator_or_opener
           # Make the obvious check first
-          return unless @processed_source.raw_source.include?(';')
+          return unless processed_source.raw_source.include?(';')
 
-          each_semicolon { |line, column| convention_on(line, column, true) }
+          each_semicolon { |line, column| register_semicolon(line, column, false) }
         end
 
         def each_semicolon
@@ -84,15 +75,32 @@ module RuboCop
         end
 
         def tokens_for_lines
-          @processed_source.tokens.group_by(&:line)
+          processed_source.tokens.group_by(&:line)
         end
 
-        def convention_on(line, column, autocorrect)
-          range = source_range(@processed_source.buffer, line, column)
-          # Don't attempt to autocorrect if semicolon is separating statements
-          # on the same line
+        def register_semicolon(line, column, after_expression)
+          range = source_range(processed_source.buffer, line, column)
+
           add_offense(range) do |corrector|
-            corrector.remove(range) if autocorrect
+            if after_expression
+              corrector.replace(range, "\n")
+            else
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def expressions_per_line(exprs)
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map(&:first_line)
+          exprs_lines.group_by(&:itself)
+        end
+
+        def find_semicolon_positions(line)
+          # Scan for all the semicolons on the line
+          semicolons = processed_source[line - 1].enum_for(:scan, ';')
+          semicolons.each do
+            yield Regexp.last_match.begin(0)
           end
         end
       end

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

@@ -109,7 +109,9 @@ module RuboCop
           # we remove any leading underscores before comparing.
           actual_args_no_underscores = actual_args.map { |arg| arg.to_s.sub(/^_+/, '') }
 
-          actual_args_no_underscores == target_args(method_name)
+          # Allow the arguments if the names match but not all are given
+          expected_args = target_args(method_name).first(actual_args_no_underscores.size)
+          actual_args_no_underscores == expected_args
         end
       end
     end

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

@@ -72,17 +72,15 @@ module RuboCop
         end
 
         def correct_to_multiline(corrector, node)
-          each_part(node.body) do |part|
-            LineBreakCorrector.break_line_before(
-              range: part, node: node, corrector: corrector,
-              configured_width: configured_indentation_width
-            )
+          if (body = node.body) && body.begin_type? && body.parenthesized_call?
+            break_line_before(corrector, node, body)
+          else
+            each_part(body) do |part|
+              break_line_before(corrector, node, part)
+            end
           end
 
-          LineBreakCorrector.break_line_before(
-            range: node.loc.end, node: node, corrector: corrector,
-            indent_steps: 0, configured_width: configured_indentation_width
-          )
+          break_line_before(corrector, node, node.loc.end, indent_steps: 0)
 
           move_comment(node, corrector)
         end
@@ -96,6 +94,13 @@ module RuboCop
           corrector.replace(node, replacement)
         end
 
+        def break_line_before(corrector, node, range, indent_steps: 1)
+          LineBreakCorrector.break_line_before(
+            range: range, node: node, corrector: corrector,
+            configured_width: configured_indentation_width, indent_steps: indent_steps
+          )
+        end
+
         def each_part(body)
           return unless body