rubocop 0.78.0 → 1.13.0

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

@@ -16,9 +16,10 @@ module RuboCop
       #   if cond then a
       #   elsif cond then b
       #   end
-      class MultilineIfThen < Cop
+      class MultilineIfThen < Base
         include OnNormalIfUnless
         include RangeHelp
+        extend AutoCorrector
 
         NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
 
@@ -27,22 +28,15 @@ module RuboCop
         def on_normal_if_unless(node)
           return unless non_modifier_then?(node)
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: node.loc.begin, side: :left)
-            )
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.begin, side: :left))
           end
         end
 
         private
 
         def non_modifier_then?(node)
-          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
         end
       end
     end

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

@@ -30,30 +30,32 @@ module RuboCop
       #     bar
       #     baz
       #   )
-      class MultilineMemoization < Cop
+      class MultilineMemoization < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        KEYWORD_MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
           _lhs, rhs = *node
 
           return unless bad_rhs?(rhs)
 
-          add_offense(rhs, location: node.source_range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.source_range) do |corrector|
             if style == :keyword
-              keyword_autocorrect(node, corrector)
+              keyword_autocorrect(rhs, corrector)
             else
-              corrector.replace(node.loc.begin, '(')
-              corrector.replace(node.loc.end, ')')
+              corrector.replace(rhs.loc.begin, '(')
+              corrector.replace(rhs.loc.end, ')')
             end
           end
         end
 
+        def message(_node)
+          style == :braces ? BRACES_MSG : KEYWORD_MSG
+        end
+
         private
 
         def bad_rhs?(rhs)
@@ -77,13 +79,13 @@ module RuboCop
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n" + (' ' * (node.loc.column + indent))
+            "begin\n#{' ' * (node.loc.column + indent)}"
           end
         end
 
         def keyword_end_str(node, node_buf)
-          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
-            "\n" + (' ' * node.loc.column) + 'end'
+          if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
+            "\n#{' ' * node.loc.column}end"
           else
             'end'
           end

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

@@ -18,7 +18,10 @@ module RuboCop
       #           baz)
       #   end
       #
-      class MultilineMethodSignature < Cop
+      class MultilineMethodSignature < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Avoid multi-line method signatures.'
 
         def on_def(node)
@@ -26,12 +29,39 @@ module RuboCop
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         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 = last_line_source_of_arguments(arguments)
+
+          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.remove(arguments_range(node))
+          corrector.insert_after(arguments.loc.begin, joined_arguments)
+        end
+
+        def last_line_source_of_arguments(arguments)
+          processed_source[arguments.last_line - 1].strip
+        end
+
+        def arguments_range(node)
+          range = range_between(
+            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
+          )
+
+          range_with_surrounding_space(range: range, side: :left)
+        end
+
         def opening_line(node)
           node.first_line
         end
@@ -53,7 +83,7 @@ module RuboCop
         end
 
         def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 80
+          config.for_cop('Layout/LineLength')['Max'] || 120
         end
       end
     end

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       #
+      # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
+      # multiline ternary operator expression, it cannot be auto-corrected.
+      #
       # @example
       #   # bad
       #   a = cond ?
@@ -17,20 +20,38 @@ module RuboCop
       #
       #   # good
       #   a = cond ? b : c
-      #   a =
-      #     if cond
-      #       b
-      #     else
-      #       c
-      #     end
-      class MultilineTernaryOperator < Cop
-        MSG = 'Avoid multi-line ternary operators, ' \
-              'use `if` or `unless` instead.'
+      #   a = if cond
+      #     b
+      #   else
+      #     c
+      #   end
+      class MultilineTernaryOperator < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
 
         def on_if(node)
-          return unless node.ternary? && node.multiline?
+          return unless offense?(node)
+
+          add_offense(node) do |corrector|
+            # `return if ... else ... end` is syntax error. If `return` is used before
+            # multiline ternary operator expression, it cannot be auto-corrected.
+            next unless offense?(node) && !node.parent.return_type?
+
+            corrector.replace(node, <<~RUBY.chop)
+              if #{node.condition.source}
+                #{node.if_branch.source}
+              else
+                #{node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+
+        private
 
-          add_offense(node)
+        def offense?(node)
+          node.ternary? && node.multiline?
         end
       end
     end

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

@@ -22,8 +22,15 @@ module RuboCop
       #   when bar then do_something
       #   end
       #
-      class MultilineWhenThen < Cop
+      #   # good
+      #   case foo
+      #   when bar then do_something(arg1,
+      #                              arg2)
+      #   end
+      #
+      class MultilineWhenThen < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use `then` for multiline `when` statement.'
 
@@ -32,23 +39,36 @@ module RuboCop
           return unless node.then?
 
           # Single line usage of `then` is not an offense
-          return if !node.children.last.nil? && !node.multiline? && node.then?
+          return if !node.children.last.nil? && !node.multiline?
 
-          # With more than one statements after then, there's not offense
-          return if node.children.last&.begin_type?
+          # Requires `then` for write `when` and its body on the same line.
+          return if require_then?(node)
 
-          add_offense(node, location: :begin)
-        end
+          # For arrays and hashes there's no offense
+          return if accept_node_type?(node.body)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          range = node.loc.begin
+          add_offense(range) do |corrector|
             corrector.remove(
-              range_with_surrounding_space(
-                range: node.loc.begin, side: :left, newlines: false
-              )
+              range_with_surrounding_space(range: range, side: :left, newlines: false)
             )
           end
         end
+
+        private
+
+        def require_then?(when_node)
+          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
+        end
+
+        def accept_node_type?(node)
+          node&.array_type? || node&.hash_type?
+        end
       end
     end
   end

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

@@ -4,7 +4,10 @@ module RuboCop
   module Cop
     module Style
       # This cop checks against comparing a variable with multiple items, where
-      # `Array#include?` could be used instead to avoid code repetition.
+      # `Array#include?`, `Set#include?` or a `case` could be used instead
+      # to avoid code repetition.
+      # It accepts comparisons of multiple method calls to avoid unnecessary method calls
+      # by default. It can be configured by `AllowMethodComparison` option.
       #
       # @example
       #   # bad
@@ -14,25 +17,71 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
-      class MultipleComparison < Cop
+      #
+      #   VALUES = Set['a', 'b', 'c'].freeze
+      #   # elsewhere...
+      #   foo if VALUES.include?(a)
+      #
+      #   case foo
+      #   when 'a', 'b', 'c' then foo
+      #   # ...
+      #   end
+      #
+      #   # accepted (but consider `case` as above)
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      # @example AllowMethodComparison: true (default)
+      #   # good
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      # @example AllowMethodComparison: false
+      #   # bad
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      #   # good
+      #   foo if [b.lightweight, b.heavyweight].include?(a)
+      class MultipleComparison < Base
+        extend AutoCorrector
+
         MSG = 'Avoid comparing a variable with multiple items ' \
           'in a conditional, use `Array#include?` instead.'
 
+        def on_new_investigation
+          @last_comparison = nil
+        end
+
         def on_or(node)
+          reset_comparison if switch_comparison?(node)
+
           root_of_or_node = root_of_or_node(node)
 
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
+          return if @allowed_method_comparison
+
+          add_offense(node) do |corrector|
+            elements = @compared_elements.join(', ')
+            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
 
-          add_offense(node)
+            corrector.replace(node, prefer_method)
+          end
+
+          @last_comparison = node
         end
 
         private
 
+        # @!method simple_double_comparison?(node)
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-        def_node_matcher :simple_comparison?, <<~PATTERN
-          {(send $lvar :== _)
-           (send _ :== $lvar)}
+
+        # @!method simple_comparison_lhs?(node)
+        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
+          (send $lvar :== $_)
+        PATTERN
+
+        # @!method simple_comparison_rhs?(node)
+        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
+          (send $_ :== $lvar)
         PATTERN
 
         def nested_variable_comparison?(node)
@@ -43,9 +92,7 @@ module RuboCop
 
         def variables_in_node(node)
           if node.or_type?
-            node.node_parts
-                .flat_map { |node_part| variables_in_node(node_part) }
-                .uniq
+            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
           else
             variables_in_simple_node(node)
           end
@@ -55,9 +102,12 @@ module RuboCop
           simple_double_comparison?(node) do |var1, var2|
             return [variable_name(var1), variable_name(var2)]
           end
-          simple_comparison?(node) do |var|
+          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
+            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
+            @compared_elements << obj.source
             return [variable_name(var)]
           end
+
           []
         end
 
@@ -74,7 +124,7 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison?(node) || nested_comparison?(node)
+          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
         end
 
         def root_of_or_node(or_node)
@@ -86,6 +136,21 @@ module RuboCop
             or_node
           end
         end
+
+        def switch_comparison?(node)
+          return true if @last_comparison.nil?
+
+          @last_comparison.descendants.none?(node)
+        end
+
+        def reset_comparison
+          @compared_elements = []
+          @allowed_method_comparison = false
+        end
+
+        def allow_method_comparison?
+          cop_config.fetch('AllowMethodComparison', true)
+        end
       end
     end
   end

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]
@@ -50,9 +52,10 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
-      class MutableConstant < Cop
+      class MutableConstant < Base
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
@@ -69,25 +72,6 @@ module RuboCop
           on_assignment(value)
         end
 
-        def autocorrect(node)
-          expr = node.source_range
-
-          lambda do |corrector|
-            splat_value = splat_value(node)
-            if splat_value
-              correct_splat_expansion(corrector, expr, splat_value)
-            elsif node.array_type? && !node.bracketed?
-              corrector.insert_before(expr, '[')
-              corrector.insert_after(expr, ']')
-            elsif requires_parentheses?(node)
-              corrector.insert_before(expr, '(')
-              corrector.insert_after(expr, ')')
-            end
-
-            corrector.insert_after(expr, '.freeze')
-          end
-        end
-
         private
 
         def on_assignment(value)
@@ -103,36 +87,57 @@ module RuboCop
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
 
-          add_offense(value)
+          add_offense(value) { |corrector| autocorrect(corrector, value) }
         end
 
         def check(value)
           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?
 
-          add_offense(value)
+          add_offense(value) { |corrector| autocorrect(corrector, value) }
+        end
+
+        def autocorrect(corrector, node)
+          expr = node.source_range
+
+          splat_value = splat_value(node)
+          if splat_value
+            correct_splat_expansion(corrector, expr, splat_value)
+          elsif node.array_type? && !node.bracketed?
+            corrector.wrap(expr, '[', ']')
+          elsif requires_parentheses?(node)
+            corrector.wrap(expr, '(', ')')
+          end
+
+          corrector.insert_after(expr, '.freeze')
         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)
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?
+          FROZEN_STRING_LITERAL_TYPES.include?(node.type) && 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?)
+          node.range_type? || (node.send_type? && node.loc.dot.nil?)
         end
 
         def correct_splat_expansion(corrector, expr, splat_value)
@@ -143,28 +148,31 @@ module RuboCop
           end
         end
 
+        # @!method splat_value(node)
         def_node_matcher :splat_value, <<~PATTERN
           (array (splat $_))
         PATTERN
 
         # Some of these patterns may not actually return an immutable object,
         # but we want to consider them immutable for this cop.
+        # @!method operation_produces_immutable_object?(node)
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
-            (send (const nil? :Struct) :new ...)
-            (block (send (const nil? :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})
             (send _ {:== :=== :!= :<= :>= :< :>} _)
-            (send (const nil? :ENV) :[] _)
-            (or (send (const nil? :ENV) :[] _) _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }
         PATTERN
 
+        # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
           (begin ({irange erange} _ _))
         PATTERN