rubocop 1.24.1 → 1.64.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for loops which iterate a constant number of times,
+      # Checks for loops which iterate a constant number of times,
       # using a Range literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #
@@ -27,27 +27,62 @@ module RuboCop
 
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
-        def on_block(node)
-          return unless offending_each_range(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless offending?(node)
 
           send_node = node.send_node
 
-          range = send_node.receiver.source_range.join(send_node.loc.selector)
-
-          add_offense(range) do |corrector|
-            range_type, min, max = offending_each_range(node)
+          add_offense(send_node) do |corrector|
+            range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node, "#{max - min}.times")
+            corrector.replace(send_node, "#{max - min}.times")
           end
         end
 
         private
 
-        # @!method offending_each_range(node)
-        def_node_matcher :offending_each_range, <<~PATTERN
-          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
+        def offending?(node)
+          return false unless node.arguments.empty?
+
+          each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
+        end
+
+        # @!method each_range(node)
+        def_node_matcher :each_range, <<~PATTERN
+          (block
+            (call
+              (begin
+                (${irange erange}
+                  (int $_) (int $_)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_with_zero_origin?(node)
+        def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
+          (block
+            (call
+              (begin
+                ({irange erange}
+                  (int 0) (int _)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_without_block_argument?(node)
+        def_node_matcher :each_range_without_block_argument?, <<~PATTERN
+          (block
+            (call
+              (begin
+                ({irange erange}
+                  (int _) (int _)))
+              :each)
+            (args)
+            ...)
         PATTERN
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for inject / reduce calls where the passed in object is
+      # Looks for inject / reduce calls where the passed in object is
       # returned at the end and so could be replaced by each_with_object without
       # the need to return the object at the end.
       #
@@ -23,13 +23,8 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        # @!method each_with_object_candidate?(node)
-        def_node_matcher :each_with_object_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
-        PATTERN
-
         def on_block(node)
-          each_with_object_candidate?(node) do |method, args, body|
+          each_with_object_block_candidate?(node) do |method, args, body|
             _, method_name, method_arg = *method
             return if simple_method_arg?(method_arg)
 
@@ -40,14 +35,38 @@ module RuboCop
 
             message = format(MSG, method: method_name)
             add_offense(method.loc.selector, message: message) do |corrector|
-              autocorrect(corrector, node, return_value)
+              autocorrect_block(corrector, node, return_value)
+            end
+          end
+        end
+
+        def on_numblock(node)
+          each_with_object_numblock_candidate?(node) do |method, body|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
+
+            return unless return_value(body)&.source == '_1'
+
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect_numblock(corrector, node)
             end
           end
         end
 
         private
 
-        def autocorrect(corrector, node, return_value)
+        # @!method each_with_object_block_candidate?(node)
+        def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
+          (block $(call _ {:inject :reduce} _) $_ $_)
+        PATTERN
+
+        # @!method each_with_object_numblock_candidate?(node)
+        def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
+          (numblock $(call _ {:inject :reduce} _) 2 $_)
+        PATTERN
+
+        def autocorrect_block(corrector, node, return_value)
           corrector.replace(node.send_node.loc.selector, 'each_with_object')
 
           first_arg, second_arg = *node.arguments
@@ -62,6 +81,18 @@ module RuboCop
           end
         end
 
+        def autocorrect_numblock(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+          # We don't remove the return value to avoid a clobbering error.
+          node.body.each_descendant do |var|
+            next unless var.lvar_type?
+
+            corrector.replace(var, '_2') if var.source == '_1'
+            corrector.replace(var, '_1') if var.source == '_2'
+          end
+        end
+
         def simple_method_arg?(method_arg)
           method_arg&.basic_literal?
         end
@@ -100,7 +131,7 @@ module RuboCop
         end
 
         def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for pipes for empty block parameters. Pipes for empty
+      # Checks for pipes for empty block parameters. Pipes for empty
       # block parameters do not cause syntax errors, but they are redundant.
       #
       # @example
@@ -28,7 +28,7 @@ module RuboCop
 
         MSG = 'Omit pipes for the empty block parameters.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           send_node = node.send_node
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end
@@ -37,7 +37,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           block = node.parent
-          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+          range = range_between(block.loc.begin.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for case statements with an empty condition.
+      # Checks for case statements with an empty condition.
       #
       # @example
       #
@@ -40,19 +40,23 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
-          return if case_node.condition
+          if case_node.condition || NOT_SUPPORTED_PARENT_TYPES.include?(case_node.parent&.type)
+            return
+          end
 
           branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
           return if branch_bodies.any? do |body|
-            body.return_type? ||
-            body.each_descendant.any?(&:return_type?)
+            body.return_type? || body.each_descendant.any?(&:return_type?)
           end
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -70,7 +74,7 @@ module RuboCop
 
           keep_first_when_comment(case_range, corrector)
 
-          when_nodes[1..-1].each do |when_node|
+          when_nodes[1..].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
         end

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

@@ -6,6 +6,34 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
       # @example EnforcedStyle: empty
       #   # warn only on empty else
       #
@@ -62,13 +90,13 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: both (default)
-      #   # warn on empty else and else with nil in it
+      # @example AllowComments: false (default)
       #
       #   # bad
       #   if condition
       #     statement
       #   else
+      #     # something comment
       #     nil
       #   end
       #
@@ -76,19 +104,26 @@ module RuboCop
       #   if condition
       #     statement
       #   else
+      #     # something comment
       #   end
       #
+      # @example AllowComments: true
+      #
       #   # good
       #   if condition
       #     statement
       #   else
-      #     statement
+      #     # something comment
+      #     nil
       #   end
       #
       #   # good
       #   if condition
       #     statement
+      #   else
+      #     # something comment
       #   end
+      #
       class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
@@ -108,6 +143,8 @@ module RuboCop
         private
 
         def check(node)
+          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
         end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for using empty heredoc to reduce redundancy.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<~EOS
+      #   EOS
+      #
+      #   <<-EOS
+      #   EOS
+      #
+      #   <<EOS
+      #   EOS
+      #
+      #   # good
+      #   ''
+      #
+      #   # bad
+      #   do_something(<<~EOS)
+      #   EOS
+      #
+      #   do_something(<<-EOS)
+      #   EOS
+      #
+      #   do_something(<<EOS)
+      #   EOS
+      #
+      #   # good
+      #   do_something('')
+      #
+      class EmptyHeredoc < Base
+        include Heredoc
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use an empty string literal instead of heredoc.'
+
+        def on_heredoc(node)
+          heredoc_body = node.loc.heredoc_body
+
+          return unless heredoc_body.source.empty?
+
+          add_offense(node) do |corrector|
+            heredoc_end = node.loc.heredoc_end
+
+            corrector.replace(node, preferred_string_literal)
+            corrector.remove(range_by_whole_lines(heredoc_body, include_final_newline: true))
+            corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
+          end
+        end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # Checks for parentheses for empty lambda parameters. Parentheses
       # for empty lambda parameters do not cause syntax errors, but they are
       # redundant.
       #
@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           send_node = node.send_node
           return unless send_node.send_type?
 
@@ -34,7 +34,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+          range = range_between(send_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of a method, the result of which
+      # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
       # @example
@@ -83,7 +83,7 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
+          node.equal?(parent.first_argument) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
@@ -119,7 +119,7 @@ module RuboCop
               # because the braces are interpreted as a block. We will have
               # to rewrite the arguments to wrap them in parenthesis.
               args = node.parent.arguments
-              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+              "(#{args[1..].map(&:source).unshift('{}').join(', ')})"
             else
               '{}'
             end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the formatting of empty method definitions.
+      # Checks for the formatting of empty method definitions.
       # By default it enforces empty method definitions to go on a single
       # line (compact style), but it can be configured to enforce the `end`
       # to go on its own line (expanded style).
@@ -11,6 +11,10 @@ module RuboCop
       # NOTE: A method definition is not considered empty if it contains
       # comments.
       #
+      # NOTE: Autocorrection will not be applied for the `compact` style
+      # if the resulting code is longer than the `Max` configuration for
+      # `Layout/LineLength`, but an offense will still be registered.
+      #
       # @example EnforcedStyle: compact (default)
       #   # bad
       #   def foo(bar)
@@ -48,10 +52,15 @@ module RuboCop
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
-          return if node.body || comment_lines?(node)
+          return if node.body || processed_source.contains_comment?(node.source_range)
           return if correct_style?(node)
 
-          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
+          add_offense(node) do |corrector|
+            correction = corrected(node)
+            next if compact_style? && max_line_length && correction.size > max_line_length
+
+            corrector.replace(node, correction)
+          end
         end
         alias on_defs on_def
 
@@ -98,6 +107,12 @@ module RuboCop
         def expanded_style?
           style == :expanded
         end
+
+        def max_line_length
+          return unless config.for_cop('Layout/LineLength')['Enabled']
+
+          config.for_cop('Layout/LineLength')['Max']
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks ensures source files have no utf-8 encoding comments.
+      # Checks ensures source files have no utf-8 encoding comments.
       # @example
       #   # bad
       #   # encoding: UTF-8
@@ -51,7 +51,7 @@ module RuboCop
             text = comment.without(:encoding)
 
             if text.blank?
-              corrector.remove(range_with_surrounding_space(range: range, side: :right))
+              corrector.remove(range_with_surrounding_space(range, side: :right))
             else
               corrector.replace(range, text)
             end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for END blocks.
+      # Checks for END blocks.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for endless methods.
+      # Checks for endless methods.
       #
       # It can enforce either the use of endless methods definitions
       # for single-lined method bodies, or disallow endless methods.
@@ -39,7 +39,7 @@ module RuboCop
       #
       # @example EnforcedStyle: disallow
       #   # bad
-      #   def my_method; x end
+      #   def my_method() = x
       #
       #   # bad
       #   def my_method() = x.foo

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for consistent usage of `ENV['HOME']`. If `nil` is used as
+      # the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`.
+      #
+      # @safety
+      #   The cop is unsafe because the result when `nil` is assigned to `ENV['HOME']` changes:
+      #
+      #   [source,ruby]
+      #   ----
+      #   ENV['HOME'] = nil
+      #   ENV['HOME'] # => nil
+      #   Dir.home    # => '/home/foo'
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   ENV['HOME']
+      #   ENV.fetch('HOME', nil)
+      #
+      #   # good
+      #   Dir.home
+      #
+      #   # good
+      #   ENV.fetch('HOME', default)
+      #
+      class EnvHome < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Dir.home` instead.'
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        # @!method env_home?(node)
+        def_node_matcher :env_home?, <<~PATTERN
+          (send
+            (const {cbase nil?} :ENV) {:[] :fetch}
+            (str "HOME")
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless env_home?(node)
+          return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, 'Dir.home')
+          end
+        end
+      end
+    end
+  end
+end