rubocop 1.18.2 → 1.19.1

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_begin.rb

@@ -84,6 +84,7 @@ module RuboCop
 
         def on_kwbegin(node)
           return if empty_begin?(node) ||
+                    begin_block_has_multiline_statements?(node) ||
                     contain_rescue_or_ensure?(node) ||
                     valid_context_using_only_begin?(node)
 
@@ -102,6 +103,9 @@ module RuboCop
               corrector.remove(offense_range)
             end
 
+            if use_modifier_form_after_multiline_begin_block?(node)
+              correct_modifier_form_after_multiline_begin_block(corrector, node)
+            end
             corrector.remove(node.loc.end)
           end
         end
@@ -127,10 +131,31 @@ module RuboCop
           corrector.insert_before(node.parent, comments) unless comments.blank?
         end
 
+        def use_modifier_form_after_multiline_begin_block?(node)
+          return unless (parent = node.parent)
+
+          node.multiline? && parent.if_type? && parent.modifier_form?
+        end
+
+        def correct_modifier_form_after_multiline_begin_block(corrector, node)
+          condition_range = condition_range(node.parent)
+
+          corrector.insert_after(node.children.first, " #{condition_range.source}")
+          corrector.remove(range_by_whole_lines(condition_range, include_final_newline: true))
+        end
+
+        def condition_range(node)
+          range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+        end
+
         def empty_begin?(node)
           node.children.empty?
         end
 
+        def begin_block_has_multiline_statements?(node)
+          node.children.count >= 2
+        end
+
         def contain_rescue_or_ensure?(node)
           first_child = node.children.first
 

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where conditional branch makes redundant self-assignment.
+      #
+      # It only detects local variable because it may replace state of instance variable,
+      # class variable, and global variable that have state across methods with `nil`.
+      #
+      # @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 use_if_and_else_branch?(expression)
+
+          if_branch = expression.if_branch
+          else_branch = expression.else_branch
+          return if inconvertible_to_modifier?(if_branch, 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
+
+        private
+
+        def use_if_and_else_branch?(expression)
+          return false unless expression&.if_type?
+
+          !expression.ternary? || !expression.else?
+        end
+
+        def inconvertible_to_modifier?(if_branch, else_branch)
+          multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
+            else_branch.respond_to?(:elsif?) && else_branch.elsif?
+        end
+
+        def multiple_statements?(branch)
+          branch && branch.children.compact.count > 1
+        end
+
+        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|
+            assignment_value = opposite_branch ? opposite_branch.source : 'nil'
+            replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+
+            corrector.replace(if_node, replacement)
+          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

@@ -36,6 +36,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
+        NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = %i[return break next].freeze
 
         def on_def(node)
           return unless node.single_line?
@@ -62,29 +63,24 @@ module RuboCop
 
         def correct_to_endless?(body_node)
           return false if target_ruby_version < 3.0
-
-          endless_method_config = config.for_cop('Style/EndlessMethod')
-
-          return false unless endless_method_config['Enabled']
-          return false if endless_method_config['EnforcedStyle'] == 'disallow'
+          return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method?
+          return false if body_node.parent.assignment_method? ||
+                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
           !(body_node.begin_type? || body_node.kwbegin_type?)
         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
@@ -98,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
 
@@ -129,6 +132,13 @@ module RuboCop
         def require_parentheses?(method_body)
           method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
         end
+
+        def disallow_endless_method_style?
+          endless_method_config = config.for_cop('Style/EndlessMethod')
+          return false unless endless_method_config['Enabled']
+
+          endless_method_config['EnforcedStyle'] == 'disallow'
+        end
       end
     end
   end

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

@@ -38,6 +38,10 @@ module RuboCop
 
         MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
 
+        def self.autocorrect_incompatible_with
+          [Style::NegatedIf, Style::NegatedUnless]
+        end
+
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
 

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

@@ -5,9 +5,14 @@ module RuboCop
     module Style
       #
       # This cop looks for uses of Perl-style global variables.
+      # Correcting to global variables in the 'English' library
+      # will add a require statement to the top of the file if
+      # enabled by RequireEnglish config.
       #
       # @example EnforcedStyle: use_english_names (default)
       #   # good
+      #   require 'English' # or this could be in another file.
+      #
       #   puts $LOAD_PATH
       #   puts $LOADED_FEATURES
       #   puts $PROGRAM_NAME
@@ -50,6 +55,8 @@ module RuboCop
       #
       class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        include RequireLibrary
         extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
@@ -90,6 +97,8 @@ module RuboCop
         # Anything *not* in this set is provided by the English library.
         NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
 
+        LIBRARY_NAME = 'English'
+
         def on_gvar(node)
           global_var, = *node
 
@@ -117,6 +126,8 @@ module RuboCop
         def autocorrect(corrector, node, global_var)
           node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
+          ensure_required(corrector, node, LIBRARY_NAME) if should_require_english?(global_var)
+
           corrector.replace(node, replacement(node, global_var))
         end
 
@@ -172,6 +183,16 @@ module RuboCop
 
           "{#{preferred_name}}"
         end
+
+        def add_require_english?
+          cop_config['RequireEnglish']
+        end
+
+        def should_require_english?(global_var)
+          style == :use_english_names &&
+            add_require_english? &&
+            !NON_ENGLISH_VARS.include?(preferred_names(global_var).first)
+        end
       end
     end
   end