rubocop 1.28.2 → 1.29.0

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -70,7 +70,7 @@ module RuboCop
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') ||
+            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
             allowed_method?(method_name)
         end
 
@@ -80,7 +80,7 @@ module RuboCop
                      else
                        method_name.dup
                      end
-          new_name << '?' unless method_name.end_with?('?')
+          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
           new_name
         end
 

data/lib/rubocop/cop/naming/variable_name.rb

@@ -19,12 +19,21 @@ module RuboCop
       #
       #   # good
       #   fooBar = 1
+      #
+      # @example AllowedPatterns: ['_v\d+\z']
+      #   # good
+      #   :release_v1
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming
+        include AllowedPattern
 
         MSG = 'Use %<style>s for variable names.'
 
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
+
         def on_lvasgn(node)
           name, = *node
           return unless name

data/lib/rubocop/cop/naming/variable_number.rb

@@ -96,12 +96,21 @@ module RuboCop
       #   # good
       #   expect(Open3).to receive(:capture3)
       #
+      # @example AllowedPatterns: ['_v\d+\z']
+      #   # good
+      #   :some_sym_v1
+      #
       class VariableNumber < Base
         include AllowedIdentifiers
         include ConfigurableNumbering
+        include AllowedPattern
 
         MSG = 'Use %<style>s for %<identifier_type>s numbers.'
 
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
+
         def on_arg(node)
           @node = node
           name, = *node
@@ -112,6 +121,7 @@ module RuboCop
         alias on_lvasgn on_arg
         alias on_ivasgn on_arg
         alias on_cvasgn on_arg
+        alias on_gvasgn on_arg
 
         def on_def(node)
           @node = node

data/lib/rubocop/cop/security/yaml_load.rb

@@ -10,7 +10,7 @@ module RuboCop
       # NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default.
       #
       # @safety
-      #   The behaviour of the code might change depending on what was
+      #   The behavior of the code might change depending on what was
       #   in the YAML payload, since `YAML.safe_load` is more restrictive.
       #
       # @example

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

@@ -76,7 +76,7 @@ module RuboCop
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          preferred_args = node.children.map { |a| a.source[1..] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
@@ -134,8 +134,8 @@ module RuboCop
         end
 
         def correct_alias_with_symbol_args(corrector, node)
-          corrector.replace(node.new_identifier, node.new_identifier.source[1..-1])
-          corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..])
         end
 
         # @!method identifier(node)

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

@@ -10,7 +10,7 @@ module RuboCop
       # @safety
       #   Auto-correction is unsafe because there is a different operator precedence
       #   between logical operators (`&&` and `||`) and semantic operators (`and` and `or`),
-      #   and that might change the behaviour.
+      #   and that might change the behavior.
       #
       # @example EnforcedStyle: always
       #   # bad

data/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb

@@ -18,7 +18,7 @@ module RuboCop
 
           def initialize(node)
             @node = node
-            @attrs = node.arguments.map { |attr| [attr.source, attr] }.to_h
+            @attrs = node.arguments.to_h { |attr| [attr.source, attr] }
             @bisection = []
           end
 

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

@@ -9,7 +9,7 @@ module RuboCop
       # @safety
       #   This cop is unsafe. `case` statements use `===` for equality,
       #   so if the original conditional used a different equality operator, the
-      #   behaviour may be different.
+      #   behavior may be different.
       #
       # @example
       #   # bad

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

@@ -33,7 +33,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          string = node.source[1..-1]
+          string = node.source[1..]
 
           # special character like \n
           # or ' which needs to use "" or be escaped.

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

@@ -70,7 +70,7 @@ module RuboCop
         def on_send(node)
           return unless (range = offense_range(node))
 
-          good = good_method_name(node.method_name)
+          good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
@@ -94,8 +94,8 @@ module RuboCop
           end
         end
 
-        def good_method_name(method_name)
-          if method_name.to_s.end_with?('!')
+        def good_method_name(node)
+          if node.bang_method?
             'compact!'
           else
             'compact'

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       # @safety
       #   Autocorrection is not safe, because `DateTime` and `Time` do not have
-      #   exactly the same behaviour, although in most cases the autocorrection
+      #   exactly the same behavior, although in most cases the autocorrection
       #   will be fine.
       #
       # @example

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

@@ -37,11 +37,27 @@ module RuboCop
       #     !!return_value
       #   end
       #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
+      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   def foo?
       #     !!return_value
       #   end
+      #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
       class DoubleNegation < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -73,22 +89,32 @@ module RuboCop
           return false unless (def_node = find_def_node_from_ascendant(node))
 
           conditional_node = find_conditional_node_from_ascendant(node)
-          last_child = find_last_child(def_node.body)
+          last_child = find_last_child(def_node.send_type? ? def_node : def_node.body)
 
           if conditional_node
             double_negative_condition_return_value?(node, last_child, conditional_node)
           else
-            last_child.last_line == node.last_line
+            last_child.last_line <= node.last_line
           end
         end
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
           return parent if parent.def_type? || parent.defs_type?
+          return node.parent.child_nodes.first if define_mehod?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
+        def define_mehod?(node)
+          return false unless node.block_type?
+
+          child = node.child_nodes.first
+          return false unless child.send_type?
+
+          child.method?(:define_method) || child.method?(:define_singleton_method)
+        end
+
         def find_conditional_node_from_ascendant(node)
           return unless (parent = node.parent)
           return parent if parent.conditional?

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

@@ -69,7 +69,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_literal.rb

@@ -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/env_home.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop 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

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

@@ -9,17 +9,32 @@ module RuboCop
       # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
       # specified default value.
       #
+      # When an `ENV[]` is the LHS of `||`, the autocorrect makes the RHS
+      # the default value of `ENV.fetch`.
+      #
       # @example
       #   # bad
       #   ENV['X']
-      #   ENV['X'] || z
+      #   ENV['X'] || 'string literal'
+      #   ENV['X'] || some_method
       #   x = ENV['X']
       #
+      #   ENV['X'] || y.map do |a|
+      #     puts a * 2
+      #   end
+      #
       #   # good
       #   ENV.fetch('X')
-      #   ENV.fetch('X', nil) || z
+      #   ENV.fetch('X', 'string literal')
+      #   ENV.fetch('X') { some_method }
       #   x = ENV.fetch('X')
       #
+      #   ENV.fetch('X') do
+      #     y.map do |a|
+      #       puts a * 2
+      #     end
+      #   end
+      #
       #   # also good
       #   !ENV['X']
       #   ENV['X'].some_method # (e.g. `.nil?`)
@@ -27,41 +42,82 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        # rubocop:disable Layout/LineLength
+        MSG_DEFAULT_NIL = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH = 'Use `ENV.fetch(%<key>s, %<default>s)` instead of `ENV[%<key>s] || %<default>s`.'
+        MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK = 'Use `ENV.fetch(%<key>s) { %<default>s }` instead of `ENV[%<key>s] || %<default>s`.'
+        MSG_DEFAULT_RHS_MULTILINE_BLOCK = 'Use `ENV.fetch(%<key>s)` with a block containing `%<default>s ...`'
+        # rubocop:enable Layout/LineLength
 
         # @!method env_with_bracket?(node)
         def_node_matcher :env_with_bracket?, <<~PATTERN
           (send (const nil? :ENV) :[] $_)
         PATTERN
 
+        # @!method operand_of_or?(node)
+        def_node_matcher :operand_of_or?, <<~PATTERN
+          (^or ...)
+        PATTERN
+
+        # @!method block_control?(node)
+        def_node_matcher :block_control?, <<~PATTERN
+          ({next | break | retry | redo})
+        PATTERN
+
+        # @!method env_with_bracket_in_descendants?(node)
+        def_node_matcher :env_with_bracket_in_descendants?, <<~PATTERN
+          `(send (const nil? :ENV) :[] $_)
+        PATTERN
+
         def on_send(node)
           env_with_bracket?(node) do |expression|
-            break if allowed_var?(expression)
-            break if allowable_use?(node)
+            break unless offensive?(node)
+
+            if operand_of_or?(node)
+              target_node = lookahead_target_node(node)
+              target_expr = env_with_bracket?(target_node)
 
-            add_offense(node, message: format(MSG, key: expression.source)) do |corrector|
-              corrector.replace(node, "ENV.fetch(#{expression.source}, nil)")
+              if default_to_rhs?(target_node)
+                default_rhs(target_node, target_expr)
+              else
+                default_nil(target_node, target_expr)
+              end
+            else
+              default_nil(node, expression)
             end
           end
         end
 
         private
 
-        def allowed_var?(expression)
-          expression.str_type? && cop_config['AllowedVars'].include?(expression.value)
+        def allowed_var?(node)
+          env_key_node = node.children.last
+          env_key_node.str_type? && cop_config['AllowedVars'].include?(env_key_node.value)
         end
 
         def used_as_flag?(node)
           return false if node.root?
+          return true if node.parent.if_type?
 
-          node.parent.if_type? || (node.parent.send_type? && node.parent.prefix_bang?)
+          node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
+        end
+
+        def offensive?(node)
+          !(allowed_var?(node) || allowable_use?(node))
+        end
+
+        def default_to_rhs?(node)
+          operand_of_or?(node) && !right_end_of_or_chains?(node) && rhs_can_be_default_value?(node)
         end
 
         # Check if the node is a receiver and receives a message with dot syntax.
         def message_chained_with_dot?(node)
           return false if node.root?
 
-          node.parent.send_type? && node.parent.children.first == node && node.parent.dot?
+          parent = node.parent
+          return false if !parent.call_type? || parent.children.first != node
+
+          parent.dot? || parent.safe_navigation?
         end
 
         # The following are allowed cases:
@@ -84,6 +140,177 @@ module RuboCop
           lhs, _method, _rhs = *parent
           node == lhs
         end
+
+        def left_end_of_or_chains?(node)
+          return false unless operand_of_or?(node)
+
+          node.parent.lhs == node
+        end
+
+        def right_end_of_or_chains?(node)
+          !(left_end_of_or_chains?(node) || node.parent&.parent&.or_type?)
+        end
+
+        # Returns the node and expression of the rightmost `ENV[]` in `||` chains.
+        # e.g.,
+        # `ENV['X'] || y || z || ENV['A'] || b`
+        #                        ^^^^^^^^ Matches this one
+        def rightmost_offense_in_or_chains(base_node)
+          or_nodes = [base_node.parent]
+
+          while (grand_parent = or_nodes.last&.parent)&.or_type?
+            or_nodes << grand_parent
+          end
+
+          # Finds the rightmost `ENV[]` in `||` chains.
+          or_node = or_nodes.reverse.find do |n|
+            env_with_bracket?(n.rhs)
+          end
+
+          or_node ? or_node.rhs : base_node
+        end
+
+        def no_env_with_bracket_in_descendants?(node)
+          !env_with_bracket_in_descendants?(node)
+        end
+
+        def conterpart_rhs_of(node)
+          left_end_of_or_chains?(node) ? node.parent.rhs : node.parent.parent.rhs
+        end
+
+        # Looks ahead to the `ENV[]` that must be corrected first, avoiding a cross correction.
+        # ```
+        # ENV['X'] || y.map do |a|
+        #   a.map do |b|
+        #     ENV['Z'] + b
+        #     ^^^^^^^^ This must be corrected first.
+        #   end
+        # end
+        # ```
+        def lookahead_target_node(base_node)
+          return base_node unless operand_of_or?(base_node)
+
+          candidate_node = rightmost_offense_in_or_chains(base_node)
+          return candidate_node if right_end_of_or_chains?(candidate_node)
+
+          counterpart_rhs = conterpart_rhs_of(candidate_node)
+          return candidate_node if no_env_with_bracket_in_descendants?(counterpart_rhs)
+
+          new_base_node = counterpart_rhs.each_descendant.find do |d|
+            env_with_bracket?(d) && offensive?(d)
+          end
+          return candidate_node unless new_base_node
+
+          lookahead_target_node(new_base_node)
+        end
+
+        def rhs_can_be_default_value?(node)
+          !rhs_is_block_control?(node)
+        end
+
+        def rhs_is_block_control?(node)
+          block_control?(conterpart_rhs_of(node))
+        end
+
+        def new_code_default_nil(expression)
+          "ENV.fetch(#{expression.source}, nil)"
+        end
+
+        def new_code_default_rhs_single_line(node, expression)
+          parent = node.parent
+          if parent.rhs.basic_literal?
+            "ENV.fetch(#{expression.source}, #{parent.rhs.source})"
+          else
+            "ENV.fetch(#{expression.source}) { #{parent.rhs.source} }"
+          end
+        end
+
+        def new_code_default_rhs_multiline(node, expression)
+          env_indent = indent(node.parent)
+          default = node.parent.rhs.source.split("\n").map do |line|
+            "#{env_indent}#{line}"
+          end.join("\n")
+          <<~NEW_CODE.chomp
+            ENV.fetch(#{expression.source}) do
+            #{configured_indentation}#{default}
+            #{env_indent}end
+          NEW_CODE
+        end
+
+        def new_code_default_rhs(node, expression)
+          if node.parent.rhs.single_line?
+            new_code_default_rhs_single_line(node, expression)
+          else
+            new_code_default_rhs_multiline(node, expression)
+          end
+        end
+
+        def default_rhs(node, expression)
+          if left_end_of_or_chains?(node)
+            default_rhs_in_same_or(node, expression)
+          else
+            default_rhs_in_outer_or(node, expression)
+          end
+        end
+
+        # Adds an offense and sets `nil` to the default value of `ENV.fetch`.
+        # `ENV['X']` --> `ENV.fetch('X', nil)`
+        def default_nil(node, expression)
+          message = format(MSG_DEFAULT_NIL, key: expression.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, new_code_default_nil(expression))
+          end
+        end
+
+        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
+        # `ENV['X'] || y` --> `ENV.fetch('X') { y }`
+        def default_rhs_in_same_or(node, expression)
+          template = message_template_for(node.parent.rhs)
+          message = format(template,
+                           key: expression.source,
+                           default: first_line_of(node.parent.rhs.source))
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.parent, new_code_default_rhs(node, expression))
+          end
+        end
+
+        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
+        # `z || ENV['X'] || y` --> `z || ENV.fetch('X') { y }`
+        def default_rhs_in_outer_or(node, expression)
+          parent = node.parent
+          grand_parent = parent.parent
+
+          template = message_template_for(grand_parent.rhs)
+          message = format(template,
+                           key: expression.source,
+                           default: first_line_of(grand_parent.rhs.source))
+
+          add_offense(node, message: message) do |corrector|
+            lhs_code = parent.lhs.source
+            rhs_code = new_code_default_rhs(parent, expression)
+            corrector.replace(grand_parent, "#{lhs_code} || #{rhs_code}")
+          end
+        end
+
+        def message_template_for(rhs)
+          if rhs.multiline?
+            MSG_DEFAULT_RHS_MULTILINE_BLOCK
+          elsif rhs.basic_literal?
+            MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH
+          else
+            MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK
+          end
+        end
+
+        def configured_indentation
+          ' ' * (config.for_cop('Layout/IndentationWidth')['Width'] || 2)
+        end
+
+        def first_line_of(source)
+          source.split("\n").first
+        end
       end
     end
   end

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

@@ -13,7 +13,7 @@ module RuboCop
       #
       # @safety
       #   Auto-correction is unsafe because changing the order of method invocations
-      #   may change the behaviour of the code. For example:
+      #   may change the behavior of the code. For example:
       #
       #   [source,ruby]
       #   ----
@@ -27,7 +27,7 @@ module RuboCop
       #   ----
       #
       #   In this example, `method_that_relies_on_global_state` will be moved before
-      #   `method_that_modifies_global_state`, which changes the behaviour of the program.
+      #   `method_that_modifies_global_state`, which changes the behavior of the program.
       #
       # @example
       #   # bad

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

@@ -29,11 +29,8 @@ module RuboCop
       #
       class MapToHash < Base
         extend AutoCorrector
-        extend TargetRubyVersion
         include RangeHelp
 
-        minimum_target_ruby_version 2.6
-
         MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
         RESTRICT_ON_SEND = %i[to_h].freeze
 

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

@@ -119,7 +119,7 @@ module RuboCop
           arguments = node.arguments.reverse
           mixins = ["#{node.method_name} #{arguments.first.source}"]
 
-          arguments[1..-1].inject(mixins) do |replacement, arg|
+          arguments[1..].inject(mixins) do |replacement, arg|
             replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
           end.join("\n")
         end

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

@@ -73,7 +73,11 @@ module RuboCop
         end
 
         def enforce_single_line_ternary_operator?(node)
-          SINGLE_LINE_TYPES.include?(node.parent.type)
+          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