rubocop 0.51.0 → 0.87.0

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

@@ -16,10 +16,10 @@ module RuboCop
       #   { result: 'ok' } if cond
       class MultilineIfModifier < Cop
         include StatementModifier
-        include AutocorrectAlignment
+        include Alignment
 
-        MSG = 'Favor a normal %s-statement over a modifier' \
-              ' clause in a multiline statement.'.freeze
+        MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
+              ' clause in a multiline statement.'
 
         def on_if(node)
           return unless node.modifier_form? && node.body.multiline?
@@ -27,16 +27,16 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, to_normal_if(node))
+            corrector.replace(node, to_normal_if(node))
           end
         end
 
+        private
+
         def message(node)
-          format(MSG, node.keyword)
+          format(MSG, keyword: node.keyword)
         end
 
         def to_normal_if(node)

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

@@ -5,43 +5,45 @@ module RuboCop
     module Style
       # Checks for uses of the `then` keyword in multi-line if statements.
       #
-      # @example This is considered bad practice:
-      #
+      # @example
+      #   # bad
+      #   # This is considered bad practice.
       #   if cond then
       #   end
       #
-      # @example If statements can contain `then` on the same line:
-      #
+      #   # good
+      #   # If statements can contain `then` on the same line.
       #   if cond then a
       #   elsif cond then b
       #   end
       class MultilineIfThen < Cop
         include OnNormalIfUnless
+        include RangeHelp
 
-        NON_MODIFIER_THEN = /then\s*(#.*)?$/
+        NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
 
-        MSG = 'Do not use `then` for multi-line `%s`.'.freeze
+        MSG = 'Do not use `then` for multi-line `%<keyword>s`.'
 
         def on_normal_if_unless(node)
           return unless non_modifier_then?(node)
 
           add_offense(node, location: :begin,
-                            message: format(MSG, node.keyword))
-        end
-
-        private
-
-        def non_modifier_then?(node)
-          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+                            message: format(MSG, keyword: node.keyword))
         end
 
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(
-              range_with_surrounding_space(node.loc.begin, :left)
+              range_with_surrounding_space(range: node.loc.begin, side: :left)
             )
           end
         end
+
+        private
+
+        def non_modifier_then?(node)
+          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
+        end
       end
     end
   end

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

@@ -5,33 +5,27 @@ module RuboCop
     module Style
       # This cop checks expressions wrapping styles for multiline memoization.
       #
-      # @example
-      #
-      #   # EnforcedStyle: keyword (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: keyword (default)
+      #   # bad
       #   foo ||= (
       #     bar
       #     baz
       #   )
       #
-      #   @good
+      #   # good
       #   foo ||= begin
       #     bar
       #     baz
       #   end
       #
-      # @example
-      #
-      #   # EnforcedStyle: braces
-      #
-      #   @bad
+      # @example EnforcedStyle: braces
+      #   # bad
       #   foo ||= begin
       #     bar
       #     baz
       #   end
       #
-      #   @good
+      #   # good
       #   foo ||= (
       #     bar
       #     baz
@@ -39,7 +33,7 @@ module RuboCop
       class MultilineMemoization < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'.freeze
+        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
 
         def on_or_asgn(node)
           _lhs, rhs = *node
@@ -49,8 +43,6 @@ module RuboCop
           add_offense(rhs, location: node.source_range)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             if style == :keyword
@@ -62,8 +54,11 @@ module RuboCop
           end
         end
 
+        private
+
         def bad_rhs?(rhs)
           return false unless rhs.multiline?
+
           if style == :keyword
             rhs.begin_type?
           else
@@ -78,7 +73,7 @@ module RuboCop
         end
 
         def keyword_begin_str(node, node_buf)
-          indent = config.for_cop('IndentationWidth')['Width'] || 2
+          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
@@ -87,7 +82,7 @@ module RuboCop
         end
 
         def keyword_end_str(node, node_buf)
-          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
+          if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
             "\n" + (' ' * node.loc.column) + 'end'
           else
             'end'

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for method signatures that span multiple lines.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo(bar, baz)
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #           baz)
+      #   end
+      #
+      class MultilineMethodSignature < Cop
+        MSG = 'Avoid multi-line method signatures.'
+
+        def on_def(node)
+          return unless node.arguments?
+          return if opening_line(node) == closing_line(node)
+          return if correction_exceeds_max_line_length?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def opening_line(node)
+          node.first_line
+        end
+
+        def closing_line(node)
+          node.arguments.last_line
+        end
+
+        def correction_exceeds_max_line_length?(node)
+          indentation_width(node) + definition_width(node) > max_line_length
+        end
+
+        def indentation_width(node)
+          processed_source.line_indentation(node.loc.expression.line)
+        end
+
+        def definition_width(node)
+          node.source_range.begin.join(node.arguments.source_range.end).length
+        end
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max'] || 80
+        end
+      end
+    end
+  end
+end

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

@@ -4,15 +4,45 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for multi-line ternary op expressions.
+      #
+      # @example
+      #   # bad
+      #   a = cond ?
+      #     b : c
+      #   a = cond ? b :
+      #       c
+      #   a = cond ?
+      #       b :
+      #       c
+      #
+      #   # 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.'.freeze
+              'use `if` or `unless` instead.'
 
         def on_if(node)
           return unless node.ternary? && node.multiline?
 
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, <<~RUBY.chop)
+              if #{node.condition.source}
+                #{node.if_branch.source}
+              else
+                #{node.else_branch.source}
+              end
+            RUBY
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks uses of the `then` keyword
+      # in multi-line when statements.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when bar then
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar then do_something
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar then do_something(arg1,
+      #                              arg2)
+      #   end
+      #
+      class MultilineWhenThen < Cop
+        include RangeHelp
+
+        MSG = 'Do not use `then` for multiline `when` statement.'
+
+        def on_when(node)
+          # Without `then`, there's no offense
+          return unless node.then?
+
+          # Single line usage of `then` is not an offense
+          return if !node.children.last.nil? && !node.multiline?
+
+          # Requires `then` for write `when` and its body on the same line.
+          return if require_then?(node)
+
+          # With more than one statements after then, there's not offense
+          return if accept_node_type?(node.body)
+
+          add_offense(node, location: :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(
+                range: node.loc.begin, side: :left, newlines: false
+              )
+            )
+          end
+        end
+
+        def require_then?(when_node)
+          return false unless when_node.body
+
+          when_node.loc.line == when_node.body.loc.line
+        end
+
+        def accept_node_type?(node)
+          node&.begin_type? || node&.array_type? || node&.hash_type?
+        end
+      end
+    end
+  end
+end

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

@@ -16,23 +16,28 @@ module RuboCop
       #   foo if ['a', 'b', 'c'].include?(a)
       class MultipleComparison < Cop
         MSG = 'Avoid comparing a variable with multiple items ' \
-          'in a conditional, use `Array#include?` instead.'.freeze
+          'in a conditional, use `Array#include?` instead.'
+
+        def on_or(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)
 
-        def on_if(node)
-          return unless nested_variable_comparison?(node.condition)
           add_offense(node)
         end
 
         private
 
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-        def_node_matcher :simple_comparison?, <<-PATTERN
+        def_node_matcher :simple_comparison?, <<~PATTERN
           {(send $lvar :== _)
            (send _ :== $lvar)}
         PATTERN
 
         def nested_variable_comparison?(node)
           return false unless nested_comparison?(node)
+
           variables_in_node(node).count == 1
         end
 
@@ -71,6 +76,16 @@ module RuboCop
         def comparison?(node)
           simple_comparison?(node) || nested_comparison?(node)
         end
+
+        def root_of_or_node(or_node)
+          return or_node unless or_node.parent
+
+          if or_node.parent.or_type?
+            root_of_or_node(or_node.parent)
+          else
+            or_node
+          end
+        end
       end
     end
   end

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

@@ -6,16 +6,55 @@ module RuboCop
       # This cop checks whether some constant value isn't a
       # mutable literal (e.g. array or hash).
       #
-      # @example
+      # Strict mode can be used to freeze all constants, rather than
+      # just literals.
+      # Strict mode is considered an experimental feature. It has not been
+      # updated with an exhaustive list of all methods that will produce
+      # frozen objects so there is a decent chance of getting some false
+      # positives. Luckily, there is no harm in freezing an already
+      # frozen object.
+      #
+      # @example EnforcedStyle: literals (default)
       #   # bad
       #   CONST = [1, 2, 3]
       #
       #   # good
       #   CONST = [1, 2, 3].freeze
+      #
+      #   # good
+      #   CONST = <<~TESTING.freeze
+      #     This is a heredoc
+      #   TESTING
+      #
+      #   # good
+      #   CONST = Something.new
+      #
+      #
+      # @example EnforcedStyle: strict
+      #   # bad
+      #   CONST = Something.new
+      #
+      #   # bad
+      #   CONST = Struct.new do
+      #     def foo
+      #       puts 1
+      #     end
+      #   end
+      #
+      #   # good
+      #   CONST = Something.new.freeze
+      #
+      #   # good
+      #   CONST = Struct.new do
+      #     def foo
+      #       puts 1
+      #     end
+      #   end.freeze
       class MutableConstant < Cop
         include FrozenStringLiteral
+        include ConfigurableEnforcedStyle
 
-        MSG = 'Freeze mutable objects assigned to constants.'.freeze
+        MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
           _scope, _const_name, value = *node
@@ -25,39 +64,108 @@ module RuboCop
         def on_or_asgn(node)
           lhs, value = *node
 
-          return unless lhs && lhs.casgn_type?
+          return unless lhs&.casgn_type?
 
           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.wrap(expr, '[', ']')
+            elsif requires_parentheses?(node)
+              corrector.wrap(expr, '(', ')')
+            end
+
+            corrector.insert_after(expr, '.freeze')
+          end
+        end
+
         private
 
         def on_assignment(value)
-          value = splat_value(value) if splat_value(value)
+          if style == :strict
+            strict_check(value)
+          else
+            check(value)
+          end
+        end
+
+        def strict_check(value)
+          return if immutable_literal?(value)
+          return if operation_produces_immutable_object?(value)
+          return if frozen_string_literal?(value)
+
+          add_offense(value)
+        end
 
-          return unless value && value.mutable_literal?
+        def check(value)
+          range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
+
+          return unless mutable_literal?(value) ||
+                        range_enclosed_in_parentheses
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
           add_offense(value)
         end
 
-        def autocorrect(node)
-          expr = node.source_range
+        def mutable_literal?(value)
+          value&.mutable_literal?
+        end
 
-          lambda do |corrector|
-            if node.array_type? && !node.bracketed?
-              corrector.insert_before(expr, '[')
-              corrector.insert_after(expr, '].freeze')
-            else
-              corrector.insert_after(expr, '.freeze')
-            end
+        def immutable_literal?(node)
+          node.nil? || node.immutable_literal?
+        end
+
+        def frozen_string_literal?(node)
+          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+            frozen_string_literals_enabled?
+        end
+
+        def requires_parentheses?(node)
+          node.range_type? ||
+            (node.send_type? && node.loc.dot.nil?)
+        end
+
+        def correct_splat_expansion(corrector, expr, splat_value)
+          if range_enclosed_in_parentheses?(splat_value)
+            corrector.replace(expr, "#{splat_value.source}.to_a")
+          else
+            corrector.replace(expr, "(#{splat_value.source}).to_a")
           end
         end
 
-        def_node_matcher :splat_value, <<-PATTERN
+        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.
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
+          {
+            (const _ _)
+            (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? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
+
+        def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
+          (begin ({irange erange} _ _))
+        PATTERN
       end
     end
   end