rubocop 1.28.2 → 1.29.1

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,84 @@ 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?
 
-          node.parent.if_type? || (node.parent.send_type? && node.parent.prefix_bang?)
+          if_node = node.ancestors.find(&:if_type?)
+          return true if if_node&.condition == node
+
+          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 +142,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/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

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

@@ -185,7 +185,7 @@ module RuboCop
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)
-          /\A\s*$/.match?(source_buffer.source[end_pos..-1])
+          /\A\s*$/.match?(source_buffer.source[end_pos..])
         end
 
         def reindentable_lines(node)

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

@@ -8,7 +8,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because changing a method signature will
-      #   implicitly change behaviour.
+      #   implicitly change behavior.
       #
       # @example
       #   # bad

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because changing a method signature will
-      #   implicitly change behaviour.
+      #   implicitly change behavior.
       #
       # @example
       #   # bad

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

@@ -116,7 +116,7 @@ module RuboCop
         def wrong_quotes?(node)
           return super if hash_key?(node)
 
-          super(node.source[1..-1])
+          super(node.source[1..])
         end
       end
     end

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

@@ -80,7 +80,7 @@ module RuboCop
           return node.source if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          exception_class = exception_node.const_name || exception_node.receiver.source
+          exception_class = exception_node.receiver&.source || exception_node.source
 
           if node.parent && requires_parens?(node.parent)
             "#{node.method_name}(#{exception_class}.new(#{argument}))"
@@ -91,6 +91,9 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
+            exception = node.first_argument
+            return if exception.send_type? && exception.first_argument&.hash_type?
+
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
               replacement = correction_exploded_to_compact(node)
 

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

@@ -44,9 +44,9 @@ module RuboCop
           message = message(node)
 
           add_offense(range_of_offense(node), message: message) do |corrector|
-            if node.ternary?
+            if node.ternary? && !branches_have_method?(node)
               correct_ternary(corrector, node)
-            elsif node.modifier_form? || !node.else_branch
+            elsif redudant_condition?(node)
               corrector.replace(node, node.if_branch.source)
             else
               corrected = make_ternary_form(node)
@@ -59,7 +59,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.modifier_form? || !node.else_branch
+          if redudant_condition?(node)
             REDUNDANT_CONDITION
           else
             MSG
@@ -68,18 +68,22 @@ module RuboCop
 
         def range_of_offense(node)
           return node.loc.expression unless node.ternary?
+          return node.loc.expression if node.ternary? && branches_have_method?(node)
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end
 
         def offense?(node)
-          condition, if_branch, else_branch = *node
+          _condition, _if_branch, else_branch = *node
 
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
-          condition == if_branch && !node.elsif? && (
-            node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?
-          )
+          synonymous_condition_and_branch?(node) && !node.elsif? &&
+            (node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?)
+        end
+
+        def redudant_condition?(node)
+          node.modifier_form? || !node.else_branch
         end
 
         def use_if_branch?(else_branch)
@@ -90,19 +94,108 @@ module RuboCop
           else_branch&.send_type? && else_branch&.method?(:[]=)
         end
 
+        def use_hash_key_access?(node)
+          node.send_type? && node.method?(:[])
+        end
+
+        def synonymous_condition_and_branch?(node)
+          condition, if_branch, _else_branch = *node
+          # e.g.
+          #   if var
+          #     var
+          #   else
+          #     'foo'
+          #   end
+          return true if condition == if_branch
+
+          # e.g.
+          #   if foo
+          #     @value = foo
+          #   else
+          #     @value = another_value?
+          #   end
+          return true if branches_have_assignment?(node) && condition == if_branch.expression
+
+          # e.g.
+          #   if foo
+          #     test.value = foo
+          #   else
+          #     test.value = another_value?
+          #   end
+          branches_have_method?(node) && condition == if_branch.first_argument &&
+            !use_hash_key_access?(if_branch)
+        end
+
+        def branches_have_assignment?(node)
+          _condition, if_branch, else_branch = *node
+
+          return false unless if_branch && else_branch
+
+          asgn_type?(if_branch) && (if_branch_variable_name = if_branch.name) &&
+            asgn_type?(else_branch) && (else_branch_variable_name = else_branch.name) &&
+            if_branch_variable_name == else_branch_variable_name
+        end
+
+        def asgn_type?(node)
+          node.lvasgn_type? || node.ivasgn_type? || node.cvasgn_type? || node.gvasgn_type?
+        end
+
+        def branches_have_method?(node)
+          _condition, if_branch, else_branch = *node
+
+          return false unless if_branch && else_branch
+
+          if_branch.send_type? && if_branch.arguments.count == 1 &&
+            else_branch.send_type? && else_branch.arguments.count == 1 &&
+            if_branch.method?(else_branch.method_name)
+        end
+
+        def if_source(if_branch)
+          if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
+            if_branch.source.delete_suffix(')')
+          else
+            if_branch.source
+          end
+        end
+
         def else_source(else_branch)
-          if require_parentheses?(else_branch)
+          if branches_have_method?(else_branch.parent)
+            else_source_if_has_method(else_branch)
+          elsif require_parentheses?(else_branch)
             "(#{else_branch.source})"
           elsif without_argument_parentheses_method?(else_branch)
             "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
+          elsif branches_have_assignment?(else_branch.parent)
+            else_source_if_has_assignment(else_branch)
           else
             else_branch.source
           end
         end
 
+        def else_source_if_has_method(else_branch)
+          if require_parentheses?(else_branch.first_argument)
+            "(#{else_branch.first_argument.source})"
+          elsif require_braces?(else_branch.first_argument)
+            "{ #{else_branch.first_argument.source} }"
+          else
+            else_branch.first_argument.source
+          end
+        end
+
+        def else_source_if_has_assignment(else_branch)
+          if require_parentheses?(else_branch.expression)
+            "(#{else_branch.expression.source})"
+          elsif require_braces?(else_branch.expression)
+            "{ #{else_branch.expression.source} }"
+          else
+            else_branch.expression.source
+          end
+        end
+
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_branch.source, else_source(else_branch)].join(' || ')
+          ternary_form = [if_source(if_branch), else_source(else_branch)].join(' || ')
+          ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
           if node.parent&.send_type?
             "(#{ternary_form})"
@@ -126,9 +219,13 @@ module RuboCop
             (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
+        def require_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
         def without_argument_parentheses_method?(node)
-          node.send_type? &&
-            !node.arguments.empty? && !node.parenthesized? && !node.operator_method?
+          node.send_type? && !node.arguments.empty? &&
+            !node.parenthesized? && !node.operator_method? && !node.assignment_method?
         end
       end
     end

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

@@ -99,7 +99,7 @@ module RuboCop
         end
 
         def backslash_b?(elem)
-          # \b's behaviour is different inside and outside of a character class, matching word
+          # \b's behavior is different inside and outside of a character class, matching word
           # boundaries outside but backspace (0x08) when inside.
           elem == '\b'
         end

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

@@ -59,7 +59,7 @@ module RuboCop
         def allowed_escape?(node, char, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
-          # rather difficult, and their behaviour could change over time with
+          # rather difficult, and their behavior could change over time with
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)

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

@@ -67,8 +67,7 @@ module RuboCop
         alias on_gvasgn on_lvasgn
 
         def on_send(node)
-          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-          return unless node.method_name.to_s.end_with?('=')
+          return unless node.assignment_method?
           return unless redundant_assignment?(node)
 
           message = format(MSG, method_name: node.first_argument.method_name)

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

@@ -23,7 +23,7 @@ module RuboCop
       #
       # @safety
       #   Autocorrection is unsafe because if a value is `false`, the resulting
-      #   code will have different behaviour or raise an error.
+      #   code will have different behavior or raise an error.
       #
       #   [source,ruby]
       #   ----

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

@@ -8,7 +8,7 @@ module RuboCop
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
       #   is actually a string. If another class has a `split` method with
-      #   different behaviour, it would be registered as a false positive.
+      #   different behavior, it would be registered as a false positive.
       #
       # @example
       #   # bad

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

@@ -167,8 +167,8 @@ module RuboCop
           allowed_methods.map(&:to_sym) + [:initialize]
         end
 
-        def dsl_writer?(method_name)
-          !method_name.to_s.end_with?('=')
+        def dsl_writer?(node)
+          !node.assignment_method?
         end
 
         def trivial_reader?(node)
@@ -180,8 +180,7 @@ module RuboCop
         end
 
         def trivial_writer?(node)
-          looks_like_trivial_writer?(node) &&
-            !allowed_method_name?(node) && !allowed_writer?(node.method_name)
+          looks_like_trivial_writer?(node) && !allowed_method_name?(node) && !allowed_writer?(node)
         end
 
         # @!method looks_like_trivial_writer?(node)
@@ -195,8 +194,8 @@ module RuboCop
             (exact_name_match? && !names_match?(node))
         end
 
-        def allowed_writer?(method_name)
-          allow_dsl_writers? && dsl_writer?(method_name)
+        def allowed_writer?(node)
+          allow_dsl_writers? && dsl_writer?(node)
         end
 
         def allowed_reader?(node)
@@ -206,11 +205,11 @@ module RuboCop
         def names_match?(node)
           ivar_name, = *node.body
 
-          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
+          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..]
         end
 
         def trivial_accessor_kind(node)
-          if trivial_writer?(node) && !dsl_writer?(node.method_name)
+          if trivial_writer?(node) && !dsl_writer?(node)
             'writer'
           elsif trivial_reader?(node)
             'reader'