rubocop 0.93.1 → 1.79.2

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for method signatures that span multiple lines.
+      # Checks for method signatures that span multiple lines.
       #
       # @example
       #
@@ -19,19 +19,53 @@ module RuboCop
       #   end
       #
       class MultilineMethodSignature < Base
+        include RangeHelp
+        extend AutoCorrector
+
         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)
+          return unless (begin_of_arguments = node.arguments.loc.begin)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node, begin_of_arguments)
+          end
         end
         alias on_defs on_def
 
         private
 
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, node, begin_of_arguments)
+          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
+
+          arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
+          # If the method name isn't on the same line as def, move it directly after def
+          if arguments_range.first_line != opening_line(node)
+            corrector.remove(node.loc.name)
+            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+          end
+
+          corrector.remove(arguments_range)
+          corrector.insert_after(begin_of_arguments, joined_arguments)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def last_line_source_of_arguments(arguments)
+          processed_source[arguments.last_line - 1].strip
+        end
+
         def opening_line(node)
           node.first_line
         end
@@ -45,7 +79,7 @@ module RuboCop
         end
 
         def indentation_width(node)
-          processed_source.line_indentation(node.loc.expression.line)
+          processed_source.line_indentation(node.source_range.line)
         end
 
         def definition_width(node)

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

@@ -3,10 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for multi-line ternary op expressions.
+      # 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.
+      # multiline ternary operator expression, it will be autocorrected to single-line
+      # ternary operator. The same is true for `break`, `next`, and method call.
       #
       # @example
       #   # bad
@@ -18,6 +19,10 @@ module RuboCop
       #       b :
       #       c
       #
+      #   return cond ?
+      #          b :
+      #          c
+      #
       #   # good
       #   a = cond ? b : c
       #   a = if cond
@@ -25,21 +30,50 @@ module RuboCop
       #   else
       #     c
       #   end
+      #
+      #   return cond ? b : c
+      #
       class MultilineTernaryOperator < Base
+        include CommentsHelp
         extend AutoCorrector
 
-        MSG = 'Avoid multi-line ternary operators, ' \
-              'use `if` or `unless` instead.'
+        MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
+        MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
+        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
 
         def on_if(node)
           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?
+          message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
-            corrector.replace(node, <<~RUBY.chop)
+          add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            autocorrect(corrector, node)
+
+            ignore_node(node)
+          end
+        end
+
+        private
+
+        def offense?(node)
+          node.ternary? && node.multiline? && node.source != replacement(node)
+        end
+
+        def autocorrect(corrector, node)
+          corrector.replace(node, replacement(node))
+          return unless (parent = node.parent)
+          return unless (comments_in_condition = comments_in_condition(node))
+
+          corrector.insert_before(parent, comments_in_condition)
+        end
+
+        def replacement(node)
+          if enforce_single_line_ternary_operator?(node)
+            "#{node.condition.source} ? #{node.if_branch.source} : #{node.else_branch.source}"
+          else
+            <<~RUBY.chop
               if #{node.condition.source}
                 #{node.if_branch.source}
               else
@@ -49,10 +83,18 @@ module RuboCop
           end
         end
 
-        private
+        def comments_in_condition(node)
+          comments_in_range(node).map do |comment|
+            "#{comment.source}\n"
+          end.join
+        end
 
-        def offense?(node)
-          node.ternary? && node.multiline?
+        def enforce_single_line_ternary_operator?(node)
+          SINGLE_LINE_TYPES.include?(node.parent&.type) && !use_assignment_method?(node.parent)
+        end
+
+        def use_assignment_method?(node)
+          node.send_type? && node.assignment_method?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks uses of the `then` keyword
+      # Checks uses of the `then` keyword
       # in multi-line when statements.
       #
       # @example
@@ -35,37 +35,24 @@ module RuboCop
         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)
-
-          # For arrays and hashes there's no offense
-          return if accept_node_type?(node.body)
+          return if !node.then? || require_then?(node)
 
           range = node.loc.begin
           add_offense(range) do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: range, side: :left, newlines: false)
-            )
+            corrector.remove(range_with_surrounding_space(range, side: :left, newlines: false))
           end
         end
 
         private
 
+        # Requires `then` for write `when` and its body on the same line.
         def require_then?(when_node)
-          return true if when_node.conditions.count >= 2
+          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?
+          same_line?(when_node, when_node.body)
         end
       end
     end

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

@@ -3,8 +3,11 @@
 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.
+      # Checks against comparing a variable with multiple items, where
+      # `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,51 +17,104 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
+      #
+      #   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)
+      #
+      # @example ComparisonsThreshold: 2 (default)
+      #   # bad
+      #   foo if a == 'a' || a == 'b'
+      #
+      # @example ComparisonsThreshold: 3
+      #   # good
+      #   foo if a == 'a' || a == 'b'
+      #
       class MultipleComparison < Base
+        extend AutoCorrector
+
         MSG = 'Avoid comparing a variable with multiple items ' \
-          'in a conditional, use `Array#include?` instead.'
+              'in a conditional, use `Array#include?` instead.'
+
+        # @!method simple_double_comparison?(node)
+        def_node_matcher :simple_double_comparison?, <<~PATTERN
+          (send lvar :== lvar)
+        PATTERN
 
+        # @!method simple_comparison_lhs(node)
+        def_node_matcher :simple_comparison_lhs, <<~PATTERN
+          (send ${lvar call} :== $_)
+        PATTERN
+
+        # @!method simple_comparison_rhs(node)
+        def_node_matcher :simple_comparison_rhs, <<~PATTERN
+          (send $_ :== ${lvar call})
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
         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)
+          return unless nested_comparison?(node)
 
-          add_offense(node)
-        end
-
-        private
+          return unless (variable, values = find_offending_var(node))
+          return if values.size < comparisons_threshold
 
-        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-        def_node_matcher :simple_comparison?, <<~PATTERN
-          {(send $lvar :== _)
-           (send _ :== $lvar)}
-        PATTERN
+          range = offense_range(values)
 
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
+          add_offense(range) do |corrector|
+            elements = values.map(&:source).join(', ')
+            argument = variable.lvar_type? ? variable_name(variable) : variable.source
+            prefer_method = "[#{elements}].include?(#{argument})"
 
-          variables_in_node(node).count == 1
+            corrector.replace(range, prefer_method)
+          end
         end
+        # rubocop:enable Metrics/AbcSize
 
-        def variables_in_node(node)
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offending_var(node, variables = Set.new, values = [])
           if node.or_type?
-            node.node_parts
-                .flat_map { |node_part| variables_in_node(node_part) }
-                .uniq
-          else
-            variables_in_simple_node(node)
+            find_offending_var(node.lhs, variables, values)
+            find_offending_var(node.rhs, variables, values)
+          elsif simple_double_comparison?(node)
+            return
+          elsif (var, obj = simple_comparison(node))
+            return if allow_method_comparison? && obj.call_type?
+
+            variables << var
+            return if variables.size > 1
+
+            values << obj
           end
+
+          [variables.first, values] if variables.any?
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def variables_in_simple_node(node)
-          simple_double_comparison?(node) do |var1, var2|
-            return [variable_name(var1), variable_name(var2)]
-          end
-          simple_comparison?(node) do |var|
-            return [variable_name(var)]
-          end
-          []
+        def offense_range(values)
+          values.first.parent.source_range.begin.join(values.last.parent.source_range.end)
         end
 
         def variable_name(node)
@@ -74,7 +130,15 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison?(node) || nested_comparison?(node)
+          !!simple_comparison(node) || nested_comparison?(node)
+        end
+
+        def simple_comparison(node)
+          if (var, obj = simple_comparison_lhs(node)) || (obj, var = simple_comparison_rhs(node))
+            return if var.call_type? && !allow_method_comparison?
+
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -86,6 +150,14 @@ module RuboCop
             or_node
           end
         end
+
+        def allow_method_comparison?
+          cop_config.fetch('AllowMethodComparison', true)
+        end
+
+        def comparisons_threshold
+          cop_config.fetch('ComparisonsThreshold', 2)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether some constant value isn't a
+      # Checks whether some constant value isn't a
       # mutable literal (e.g. array or hash).
       #
       # Strict mode can be used to freeze all constants, rather than
@@ -14,6 +14,25 @@ module RuboCop
       # positives. Luckily, there is no harm in freezing an already
       # frozen object.
       #
+      # From Ruby 3.0, this cop honours the magic comment
+      # 'shareable_constant_value'. When this magic comment is set to any
+      # acceptable value other than none, it will suppress the offenses
+      # raised by this cop. It enforces frozen state.
+      #
+      # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
+      #
+      # NOTE: From Ruby 3.0, interpolated strings are not frozen when
+      # `# frozen-string-literal: true` is used, so this cop enforces explicit
+      # freezing for such strings.
+      #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when
+      # the `shareable_constant_value` directive is used.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe since any mutations on objects that
+      #   are made frozen will change from being accepted to raising `FrozenError`,
+      #   and will need to be manually refactored.
+      #
       # @example EnforcedStyle: literals (default)
       #   # bad
       #   CONST = [1, 2, 3]
@@ -50,7 +69,55 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
+      #
+      # @example
+      #   # Magic comment - shareable_constant_value: literal
+      #
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   # shareable_constant_value: literal
+      #   CONST = [1, 2, 3]
+      #
       class MutableConstant < Base
+        # Handles magic comment shareable_constant_value with O(n ^ 2) complexity
+        # n - number of lines in the source
+        # Iterates over all lines before a CONSTANT
+        # until it reaches shareable_constant_value
+        module ShareableConstantValue
+          module_function
+
+          def recent_shareable_value?(node)
+            shareable_constant_comment = magic_comment_in_scope node
+            return false if shareable_constant_comment.nil?
+
+            shareable_constant_value = MagicComment.parse(shareable_constant_comment)
+                                                   .shareable_constant_value
+            shareable_constant_value_enabled? shareable_constant_value
+          end
+
+          # Identifies the most recent magic comment with valid shareable constant values
+          # that's in scope for this node
+          def magic_comment_in_scope(node)
+            processed_source_till_node(node).reverse_each.find do |line|
+              MagicComment.parse(line).valid_shareable_constant_value?
+            end
+          end
+
+          private
+
+          def processed_source_till_node(node)
+            processed_source.lines[0..(node.last_line - 1)]
+          end
+
+          def shareable_constant_value_enabled?(value)
+            %w[literal experimental_everything experimental_copy].include? value
+          end
+        end
+        private_constant :ShareableConstantValue
+
+        include ShareableConstantValue
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -58,16 +125,14 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
-          _scope, _const_name, value = *node
-          on_assignment(value)
-        end
+          if node.expression.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?
-
-          on_assignment(value)
+            on_assignment(parent.children.last)
+          else
+            on_assignment(node.expression)
+          end
         end
 
         private
@@ -84,23 +149,20 @@ module RuboCop
           return if immutable_literal?(value)
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
 
-          add_offense(value) do |corrector|
-            autocorrect(corrector, value)
-          end
+          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
-          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
-                    frozen_string_literals_enabled?
+                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
 
-          add_offense(value) do |corrector|
-            autocorrect(corrector, value)
-          end
+          return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
+
+          add_offense(value) { |corrector| autocorrect(corrector, value) }
         end
 
         def autocorrect(corrector, node)
@@ -119,21 +181,27 @@ module RuboCop
         end
 
         def mutable_literal?(value)
-          value&.mutable_literal?
+          return false if frozen_regexp_or_range_literals?(value)
+
+          value.mutable_literal?
         end
 
         def immutable_literal?(node)
-          node.nil? || node.immutable_literal?
+          frozen_regexp_or_range_literals?(node) || node.immutable_literal?
+        end
+
+        def shareable_constant_value?(node)
+          return false if target_ruby_version < 3.0
+
+          recent_shareable_value? node
         end
 
-        def frozen_string_literal?(node)
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?
+        def frozen_regexp_or_range_literals?(node)
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         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)
@@ -144,12 +212,14 @@ 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 _ _)
@@ -166,8 +236,9 @@ module RuboCop
           }
         PATTERN
 
+        # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
-          (begin ({irange erange} _ _))
+          (begin (range _ _))
         PATTERN
       end
     end

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

@@ -90,8 +90,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? ||
-            style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end