rubocop 1.81.7 → 1.92.1

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

@@ -9,9 +9,11 @@ module RuboCop
       # call to `transform_values` instead.
       #
       # @safety
-      #   This cop is unsafe, as it can produce false positives if we are
-      #   transforming an enumerable of key-value-like pairs that isn't actually
-      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -19,10 +21,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
       #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   foo.merge(bar).map { |k, v| [k, v.to_s] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
+      #   foo.to_h.transform_values { |v| foo(v) }
+      #   foo.merge(bar).transform_values { |v| v.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
+      #   baz.map { |k, v| [k, v.to_s] }.to_h
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -33,7 +43,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
@@ -48,7 +58,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -59,7 +69,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -70,7 +80,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

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

@@ -136,7 +136,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -168,7 +168,6 @@ module RuboCop
 
           check_expressions(node, heads, :before_condition)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -189,7 +188,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -199,8 +198,7 @@ module RuboCop
             add_offense(expression) do |corrector|
               next if node.if_type? && (node.ternary? || node.then?)
 
-              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
-              corrector.remove(range)
+              corrector.remove(removal_range(expression))
               next if inserted_expression
 
               if node.parent&.assignment?
@@ -213,26 +211,56 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def removal_range(expression)
+          range = expression.source_range
+          whole_lines = range_by_whole_lines(range, include_final_newline: true)
+          return whole_lines if whole_lines.source.strip == expression.source
+
+          range_with_separator(range)
+        end
+
+        def range_with_separator(range)
+          source = range.source_buffer.source
+
+          if (following = source[range.end_pos..][/\A[ \t]*;[ \t]*/])
+            range.adjust(end_pos: following.length)
+          elsif (preceding = source[0...range.begin_pos][/[ \t]*;[ \t]*\z/])
+            range.adjust(begin_pos: -preceding.length)
+          else
+            range_with_surrounding_space(range, side: :right, newlines: false)
+          end
+        end
 
         def correct_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node.parent)
+
           if insert_position == :after_condition
             assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
             corrector.remove(assignment)
-            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{assignment.source}#{expression.source}")
           else
-            corrector.insert_before(node.parent, "#{expression.source}\n")
+            corrector.insert_before(node.parent, "#{expression.source}\n#{indentation}")
           end
         end
 
         def correct_no_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node)
+
           if insert_position == :after_condition
-            corrector.insert_after(node, "\n#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{expression.source}")
           else
-            corrector.insert_before(node, "#{expression.source}\n")
+            corrector.insert_before(node, "#{expression.source}\n#{indentation}")
           end
         end
 
+        # The leading indentation of the line the conditional starts on, so a
+        # hoisted expression keeps the surrounding nesting instead of landing
+        # at column zero.
+        def indentation_of(node)
+          ' ' * node.source_range.column
+        end
+
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)
 

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
           return if node.ternary? || node.unless?
 
@@ -72,20 +72,40 @@ module RuboCop
 
           return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
+          return if comments_between_else_and_if?(node, else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
-            next if part_of_ignored_node?(node)
+            next if part_of_ignored_node?(node) || shares_lines_with_other_code?(else_branch)
 
             autocorrect(corrector, else_branch)
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
+        # The `elsif` correction moves and removes whole lines, so it can't be applied when
+        # the nested `if` condition, its `if` branch or its `end` shares a line with other code.
+        # A modifier `if` on the `else` line would leave its body on the `elsif` line.
+        def shares_lines_with_other_code?(node)
+          return false if node.then?
+          return !begins_its_line?(node.source_range) if node.modifier_form?
+
+          moved_ranges(node).any? { |range| !begins_its_line?(range) || !ends_its_line?(range) }
+        end
+
+        def moved_ranges(node)
+          ranges = [if_condition_range(node, node.condition), find_end_range(node)]
+          ranges << range_with_comments(node.if_branch) if node.if_branch
+          ranges
+        end
+
+        def ends_its_line?(range)
+          processed_source.lines[range.last_line - 1][range.last_column..].match?(/\A\s*(#|\z)/)
+        end
+
         def autocorrect(corrector, node)
-          if then?(node)
+          if node.then?
             # If the nested `if` is a then node, correct it first,
             # then the next pass will use `correct_to_elsif_from_if_inside_else_form`
             IfThenCorrector.new(node, indentation: 0).call(corrector)
@@ -124,10 +144,6 @@ module RuboCop
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
         end
 
-        def then?(node)
-          node.loc.begin&.source == 'then'
-        end
-
         def find_end_range(node)
           end_range = node.loc.end
           return end_range if end_range
@@ -139,6 +155,18 @@ module RuboCop
           range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
         end
 
+        def comments_between_else_and_if?(node, else_branch)
+          return false if else_branch.modifier_form?
+
+          else_end = node.loc.else.end_pos
+          if_begin = else_branch.loc.keyword.begin_pos
+
+          processed_source.comments.any? do |comment|
+            comment_pos = comment.source_range.begin_pos
+            comment_pos > else_end && comment_pos < if_begin
+          end
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -71,10 +71,9 @@ module RuboCop
       #   if short_condition # a long comment that makes it too long if it were just a single line
       #     do_something
       #   end
+      #
       class IfUnlessModifier < Base
         include StatementModifier
-        include LineLengthHelp
-        include AllowedPattern
         include RangeHelp
         include CommentsHelp
         extend AutoCorrector
@@ -82,30 +81,35 @@ module RuboCop
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
                            'the usage of control flow `&&`/`||`.'
+        MSG_USE_MODIFIER_PARENS = 'Favor modifier `%<keyword>s` usage when having a ' \
+                                  'single-line body. Wrap the expression in parentheses ' \
+                                  'to keep the current behavior, as it is part of a ' \
+                                  'larger expression.'
         MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
-          [Style::SoleNestedConditional]
+          [Style::Next, Style::SoleNestedConditional]
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body)
+          return if endless_method?(node.body) || node.each_ancestor(:dstr).any?
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
                     pattern_matching_nodes(condition).any?
 
           return unless (msg = message(node))
+          return if modifier_sharing_line_in_logical_operator?(node)
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             next if part_of_ignored_node?(node)
+            next if another_modifier_if_on_same_line?(node)
 
             autocorrect(corrector, node)
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -117,7 +121,7 @@ module RuboCop
           if condition.defined_type?
             [condition]
           else
-            condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant(:defined?)
           end
         end
 
@@ -135,13 +139,13 @@ module RuboCop
           if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select(&:any_match_pattern_type?)
+            condition.each_descendant(:any_match_pattern)
           end
         end
 
         def message(node)
           if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-            MSG_USE_MODIFIER
+            parenthesize?(node) ? MSG_USE_MODIFIER_PARENS : MSG_USE_MODIFIER
           elsif too_long_due_to_modifier?(node)
             MSG_USE_NORMAL
           end
@@ -156,7 +160,7 @@ module RuboCop
           corrector.replace(node, replacement)
         end
 
-        def replacement_for_modifier_form(corrector, node) # rubocop:disable Metrics/AbcSize
+        def replacement_for_modifier_form(corrector, node)
           comment = comment_on_node_line(node)
           if comment && too_long_due_to_comment_after_modifier?(node, comment)
             remove_comment(corrector, node, comment)
@@ -164,12 +168,11 @@ module RuboCop
             return to_modifier_form_with_move_comment(node, indent(node), comment)
           end
 
-          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
-          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
-            heredoc = extract_heredoc_from(last_argument)
-            remove_heredoc(corrector, heredoc)
+          heredoc_ranges = heredoc_ranges_in(node)
+          unless heredoc_ranges.empty?
+            remove_heredoc(corrector, heredoc_ranges)
 
-            return to_normal_form_with_heredoc(node, indent(node), heredoc)
+            return to_normal_form_with_heredoc(node, indent(node))
           end
 
           to_normal_form(node, indent(node))
@@ -186,69 +189,71 @@ module RuboCop
           max_line_length.between?(source_length - comment.source_range.length, source_length)
         end
 
-        def allowed_patterns
-          line_length_config = config.for_cop('Layout/LineLength')
-          line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
-        end
-
         def too_long_single_line?(node)
-          return false unless max_line_length
-
           range = node.source_range
-          return false unless range.single_line?
-          return false unless line_length_enabled_at_line?(range.first_line)
+          range.single_line? && !acceptable_line_length?(range.source_line, range.first_line)
+        end
 
-          line = range.source_line
-          return false if line_length(line) <= max_line_length
+        def named_capture_in_condition?(node)
+          node.condition.match_with_lvasgn_type?
+        end
 
-          too_long_line_based_on_config?(range, line)
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? ||
+            multiline_inside_collection?(node) || super
         end
 
-        def too_long_line_based_on_config?(range, line)
-          return false if matches_allowed_pattern?(line)
+        def multiline_inside_collection?(node)
+          return false if node.modifier_form?
+          return false unless (collection = find_containing_collection(node))
 
-          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
-          return too_long unless too_long == :undetermined
+          collection.children.any? { |child| sibling_if_shares_line?(child, node) }
+        end
 
-          too_long_line_based_on_allow_uri?(line)
+        def sibling_if_shares_line?(child, node)
+          inner = unwrap_begin(child)
+          inner&.if_type? && !inner.ternary? && shares_line_with?(inner, node)
         end
 
-        def too_long_line_based_on_ignore_cop_directives?(range, line)
-          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
-            return line_length_without_directive(line) > max_line_length
-          end
+        def unwrap_begin(node)
+          return unless node.is_a?(RuboCop::AST::Node)
 
-          :undetermined
+          node = node.value if node.pair_type?
+          node.begin_type? ? node.children.first : node
         end
 
-        def too_long_line_based_on_allow_uri?(line)
-          if allow_uri?
-            uri_range = find_excessive_range(line, :uri)
-            return false if uri_range && allowed_position?(line, uri_range)
-          end
-
-          true
+        def shares_line_with?(inner, node)
+          same_line?(inner, node.loc.end) || same_line?(inner.loc.end, node)
         end
 
-        def too_long_line_based_on_allow_qualified_name?(line)
-          if allow_qualified_name?
-            namespace_range = find_excessive_range(line, :namespace)
-            return false if namespace_range && allowed_position?(line, namespace_range)
-          end
+        def find_containing_collection(node)
+          parent = node.parent
+          return collection_from_ancestor(parent) unless parent&.begin_type?
 
-          true
+          collection_from_ancestor(parent.parent)
         end
 
-        def line_length_enabled_at_line?(line)
-          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
+        def collection_from_ancestor(node)
+          return node if node&.type?(:array, :call, :and, :or)
+
+          node.parent if node&.type?(:pair)
         end
 
-        def named_capture_in_condition?(node)
-          node.condition.match_with_lvasgn_type?
+        def modifier_sharing_line_in_logical_operator?(node)
+          collection = find_containing_collection(node)
+          return false if !node.modifier_form? || !collection&.operator_keyword?
+
+          another_modifier_if_on_same_line?(node)
         end
 
-        def non_eligible_node?(node)
-          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
+        def another_modifier_if_on_same_line?(node)
+          collection = find_containing_collection(node)
+          return false unless collection
+
+          line = node.source_range.line
+          collection.each_descendant(:if).any? do |sibling|
+            sibling != node && sibling.modifier_form? && sibling.source_range.line == line
+          end
         end
 
         def non_simple_if_unless?(node)
@@ -277,16 +282,20 @@ module RuboCop
           RUBY
         end
 
-        def to_normal_form_with_heredoc(node, indentation, heredoc)
-          heredoc_body, heredoc_end = heredoc
+        def remove_heredoc(corrector, heredoc_ranges)
+          heredoc_ranges.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
 
-          <<~RUBY.chomp
-            #{node.keyword} #{node.condition.source}
-            #{indentation}  #{node.body.source}
-            #{indentation}  #{heredoc_body.source.chomp}
-            #{indentation}  #{heredoc_end.source.chomp}
-            #{indentation}end
-          RUBY
+        def to_normal_form_with_heredoc(node, indentation)
+          [
+            "#{node.keyword} #{node.condition.source}",
+            *heredoc_ranges_in(node.condition).map(&:source),
+            "#{indentation}  #{node.body.source}",
+            *heredoc_ranges_in(node.if_branch).map(&:source),
+            "#{indentation}end"
+          ].join("\n")
         end
 
         def to_modifier_form_with_move_comment(node, indentation, comment)
@@ -296,21 +305,16 @@ module RuboCop
           RUBY
         end
 
-        def extract_heredoc_from(last_argument)
-          heredoc_body = last_argument.loc.heredoc_body
-          heredoc_end = last_argument.loc.heredoc_end
-
-          [heredoc_body, heredoc_end]
-        end
-
-        def remove_heredoc(corrector, heredoc)
-          heredoc.each do |range|
-            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        def heredoc_ranges_in(body)
+          ranges = body.each_node(:any_str).select(&:heredoc?).map do |heredoc|
+            range_by_whole_lines(heredoc.loc.heredoc_body.join(heredoc.loc.heredoc_end))
           end
+          # A heredoc opened in another heredoc's interpolation is moved along with it.
+          ranges.reject { |range| ranges.any? { |other| other.contains?(range) } }
         end
 
         def comment_on_node_line(node)
-          processed_source.comments.find { |c| same_line?(c, node) }
+          processed_source.comment_at_line(node.first_line)
         end
 
         def remove_comment(corrector, _node, comment)

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

@@ -8,27 +8,31 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  tired? ? 'stop' : 'go faster' if running?
+      #   # bad
+      #   tired? ? 'stop' : 'go faster' if running?
       #
-      #  # bad
-      #  if tired?
-      #    "please stop"
-      #  else
-      #    "keep going"
-      #  end if running?
+      #   # bad
+      #   if tired?
+      #     "please stop"
+      #   else
+      #     "keep going"
+      #   end if running?
       #
-      #  # good
-      #  if running?
-      #    tired? ? 'stop' : 'go faster'
-      #  end
+      #   # good
+      #   if running?
+      #     tired? ? 'stop' : 'go faster'
+      #   end
       class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
         extend AutoCorrector
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
-        # rubocop:disable Metrics/AbcSize
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
+        # rubocop:disable-next Metrics/AbcSize
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
@@ -37,7 +41,6 @@ module RuboCop
             corrector.remove(node.if_branch.source_range.end.join(node.condition.source_range.end))
           end
         end
-        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -54,7 +54,10 @@ module RuboCop
       #   # good (but potentially an unsafe correction)
       #   foo.do_something?
       #
-      # @example AllowedMethods: ['nonzero?'] (default)
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
       #   # good
       #   num.nonzero? ? true : false
       #