rubocop 1.29.0 → 1.30.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for missing top-level documentation of classes and
+      # Checks for missing top-level documentation of classes and
       # modules. Classes with no body are exempt from the check and so are
       # namespace modules - modules that have nothing in their bodies except
       # classes, other modules, constant definitions or constant visibility

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for missing documentation comment for public methods.
+      # Checks for missing documentation comment for public methods.
       # It can optionally be configured to also require documentation for
       # non-public methods.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of double negation (`!!`) to convert something to a boolean value.
+      # Checks for uses of double negation (`!!`) to convert something to a boolean value.
       #
       # When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts
       # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation

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`.
       #

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.
       #

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

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
       #

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

@@ -6,20 +6,20 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
-      # @example EnforcedStyle: empty
-      #   # warn only on empty else
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
       #
       #   # bad
       #   if condition
       #     statement
       #   else
+      #     nil
       #   end
       #
-      #   # good
+      #   # bad
       #   if condition
       #     statement
       #   else
-      #     nil
       #   end
       #
       #   # good
@@ -34,20 +34,20 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: nil
-      #   # warn on else with nil in it
+      # @example EnforcedStyle: empty
+      #   # warn only on empty else
       #
       #   # bad
       #   if condition
       #     statement
       #   else
-      #     nil
       #   end
       #
       #   # good
       #   if condition
       #     statement
       #   else
+      #     nil
       #   end
       #
       #   # good
@@ -62,8 +62,8 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: both (default)
-      #   # warn on empty else and else with nil in it
+      # @example EnforcedStyle: nil
+      #   # warn on else with nil in it
       #
       #   # bad
       #   if condition
@@ -72,7 +72,7 @@ module RuboCop
       #     nil
       #   end
       #
-      #   # bad
+      #   # good
       #   if condition
       #     statement
       #   else

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.
       #

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

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).

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

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.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for consistent usage of `ENV['HOME']`. If `nil` is used as
+      # 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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
       # and `module_eval`) are given filename and line number values (`__FILE__`
       # and `__LINE__`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where `Integer#even?` or `Integer#odd?`
+      # Checks for places where `Integer#even?` or `Integer#odd?`
       # can be used.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for use of the `File.expand_path` arguments.
+      # Checks for use of the `File.expand_path` arguments.
       # Likewise, it also checks for the `Pathname.new` argument.
       #
       # Contrastive bad case and good case are alternately shown in

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of explicit block argument to avoid writing
+      # Enforces the use of explicit block argument to avoid writing
       # block literal that just passes its arguments to another block.
       #
       # NOTE: This cop only registers an offense if the block args match the

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces consistency when using exponential notation
+      # Enforces consistency when using exponential notation
       # for numbers in the code (eg 1.2e4). Different styles are supported:
       #
       # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop suggests `ENV.fetch` for the replacement of `ENV[]`.
+      # Suggests `ENV.fetch` for the replacement of `ENV[]`.
       # `ENV[]` silently fails and returns `nil` when the environment variable is unset,
       # which may cause unexpected behaviors when the developer forgets to set it.
       # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
@@ -64,26 +64,26 @@ module RuboCop
           ({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) :[] $_)
+        # @!method offensive_nodes(node)
+        def_node_search :offensive_nodes, <<~PATTERN
+          [#env_with_bracket? #offensive?]
         PATTERN
 
         def on_send(node)
-          env_with_bracket?(node) do |expression|
+          env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
             if operand_of_or?(node)
-              target_node = lookahead_target_node(node)
-              target_expr = env_with_bracket?(target_node)
+              target_node = offensive_nodes(or_chain_root(node)).to_a.last
+              target_name_node = env_with_bracket?(target_node)
 
               if default_to_rhs?(target_node)
-                default_rhs(target_node, target_expr)
+                default_rhs(target_node, target_name_node)
               else
-                default_nil(target_node, target_expr)
+                default_nil(target_node, target_name_node)
               end
             else
-              default_nil(node, expression)
+              default_nil(node, name_node)
             end
           end
         end
@@ -97,15 +97,46 @@ module RuboCop
 
         def used_as_flag?(node)
           return false if node.root?
-          return true if node.parent.if_type?
+          return true if used_if_condition_in_body(node)
 
           node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
         end
 
+        def used_if_condition_in_body(node)
+          if_node = node.ancestors.find(&:if_type?)
+
+          return false unless (condition = if_node&.condition)
+          return true if condition.send_type? && (condition.child_nodes == node.child_nodes)
+
+          used_in_condition?(node, condition)
+        end
+
+        def used_in_condition?(node, condition)
+          if condition.send_type?
+            return true if condition.assignment_method? && partial_matched?(node, condition)
+            return false if !condition.comparison_method? && !condition.predicate_method?
+          end
+
+          condition.child_nodes.any?(node)
+        end
+
+        # Avoid offending in the following cases:
+        # `ENV['key'] if ENV['key'] = x`
+        def partial_matched?(node, condition)
+          node.child_nodes == node.child_nodes & condition.child_nodes
+        end
+
         def offensive?(node)
           !(allowed_var?(node) || allowable_use?(node))
         end
 
+        def or_chain_root(node)
+          while operand_of_or?(ancestor_or ||= node.parent)
+            ancestor_or = ancestor_or.parent
+          end
+          ancestor_or
+        end
+
         def default_to_rhs?(node)
           operand_of_or?(node) && !right_end_of_or_chains?(node) && rhs_can_be_default_value?(node)
         end
@@ -151,59 +182,10 @@ module RuboCop
           !(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
@@ -212,84 +194,84 @@ module RuboCop
           block_control?(conterpart_rhs_of(node))
         end
 
-        def new_code_default_nil(expression)
-          "ENV.fetch(#{expression.source}, nil)"
+        def new_code_default_nil(name_node)
+          "ENV.fetch(#{name_node.source}, nil)"
         end
 
-        def new_code_default_rhs_single_line(node, expression)
+        def new_code_default_rhs_single_line(node, name_node)
           parent = node.parent
           if parent.rhs.basic_literal?
-            "ENV.fetch(#{expression.source}, #{parent.rhs.source})"
+            "ENV.fetch(#{name_node.source}, #{parent.rhs.source})"
           else
-            "ENV.fetch(#{expression.source}) { #{parent.rhs.source} }"
+            "ENV.fetch(#{name_node.source}) { #{parent.rhs.source} }"
           end
         end
 
-        def new_code_default_rhs_multiline(node, expression)
+        def new_code_default_rhs_multiline(node, name_node)
           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
+            ENV.fetch(#{name_node.source}) do
             #{configured_indentation}#{default}
             #{env_indent}end
           NEW_CODE
         end
 
-        def new_code_default_rhs(node, expression)
+        def new_code_default_rhs(node, name_node)
           if node.parent.rhs.single_line?
-            new_code_default_rhs_single_line(node, expression)
+            new_code_default_rhs_single_line(node, name_node)
           else
-            new_code_default_rhs_multiline(node, expression)
+            new_code_default_rhs_multiline(node, name_node)
           end
         end
 
-        def default_rhs(node, expression)
+        def default_rhs(node, name_node)
           if left_end_of_or_chains?(node)
-            default_rhs_in_same_or(node, expression)
+            default_rhs_in_same_or(node, name_node)
           else
-            default_rhs_in_outer_or(node, expression)
+            default_rhs_in_outer_or(node, name_node)
           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)
+        def default_nil(node, name_node)
+          message = format(MSG_DEFAULT_NIL, key: name_node.source)
 
           add_offense(node, message: message) do |corrector|
-            corrector.replace(node, new_code_default_nil(expression))
+            corrector.replace(node, new_code_default_nil(name_node))
           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)
+        def default_rhs_in_same_or(node, name_node)
           template = message_template_for(node.parent.rhs)
           message = format(template,
-                           key: expression.source,
+                           key: name_node.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))
+            corrector.replace(node.parent, new_code_default_rhs(node, name_node))
           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)
+        def default_rhs_in_outer_or(node, name_node)
           parent = node.parent
           grand_parent = parent.parent
 
           template = message_template_for(grand_parent.rhs)
           message = format(template,
-                           key: expression.source,
+                           key: name_node.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)
+            rhs_code = new_code_default_rhs(parent, name_node)
             corrector.replace(grand_parent, "#{lhs_code} || #{rhs_code}")
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for division with integers coerced to floats.
+      # Checks for division with integers coerced to floats.
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of the `for` keyword or `each` method. The
+      # Looks for uses of the `for` keyword or `each` method. The
       # preferred alternative is set in the EnforcedStyle configuration
       # parameter. An `each` call with a block on a single line is always
       # allowed.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of a single string formatting utility.
+      # Enforces the use of a single string formatting utility.
       # Valid options include Kernel#format, Kernel#sprintf and String#%.
       #
       # The detection of String#% cannot be implemented in a reliable

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is designed to help you transition from mutable string literals
+      # Helps you transition from mutable string literals
       # to frozen string literals.
       # It will add the `# frozen_string_literal: true` magic comment to the top
       # of files to enable frozen string literals. Frozen string literals may be
       # default in future Ruby. The comment will be added below a shebang and
-      # encoding comment.
+      # encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.
       #
       # Note that the cop will accept files where the comment exists but is set
       # to `false` instead of `true`.
@@ -86,6 +86,9 @@ module RuboCop
         include FrozenStringLiteral
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: true`.'
         MSG_MISSING = 'Missing frozen string literal comment.'

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+      # Enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
       # `STDOUT/STDERR/STDIN` are constants, and while you can actually
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of global variables.
+      # Looks for uses of global variables.
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.

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

@@ -73,7 +73,7 @@ module RuboCop
       #     work
       #   end
       #
-      #   do_someting
+      #   do_something
       #
       #   if bar?  # <- reports an offense
       #     work

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and
+      # Checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and
       # sequences of values to hashes.
       #
       # Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example,

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `each_key` and `each_value` Hash methods.
+      # Checks for uses of `each_key` and `each_value` Hash methods.
       #
       # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
       # that can be replaced with `Hash#except` method.
       #
       # This cop should only be enabled on Ruby version 3.0 or higher.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where `case-when` represents a simple 1:1
+      # Checks for places where `case-when` represents a simple 1:1
       # mapping and can be replaced with a hash lookup.
       #
       # @example MinBranchesCount: 3 (default)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks hash literal syntax.
+      # Checks hash literal syntax.
       #
       # It can enforce either the use of the class hash rocket syntax or
       # the use of the newer Ruby 1.9 syntax (when applicable).