rubocop 1.26.1 → 1.32.0

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # 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
+      # specified default value.
+      #
+      # @example
+      #   # bad
+      #   ENV['X']
+      #   x = ENV['X']
+      #
+      #   # good
+      #   ENV.fetch('X')
+      #   x = ENV.fetch('X')
+      #
+      #   # also good
+      #   !ENV['X']
+      #   ENV['X'].some_method # (e.g. `.nil?`)
+      #
+      class FetchEnvVar < Base
+        extend AutoCorrector
+
+        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+
+        # @!method env_with_bracket?(node)
+        def_node_matcher :env_with_bracket?, <<~PATTERN
+          (send (const nil? :ENV) :[] $_)
+        PATTERN
+
+        def on_send(node)
+          env_with_bracket?(node) do |name_node|
+            break unless offensive?(node)
+
+            message = format(MSG, key: name_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, new_code(name_node))
+            end
+          end
+        end
+
+        private
+
+        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 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
+
+        # 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?
+
+          parent = node.parent
+          return false if !parent.call_type? || parent.children.first != node
+
+          parent.dot? || parent.safe_navigation?
+        end
+
+        # The following are allowed cases:
+        #
+        # - Used as a flag (e.g., `if ENV['X']` or `!ENV['X']`) because
+        #   it simply checks whether the variable is set.
+        # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
+        # - `ENV['key']` assigned by logical AND/OR assignment.
+        # - `ENV['key']` is the LHS of a `||`.
+        def allowable_use?(node)
+          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node) || or_lhs?(node)
+        end
+
+        # The following are allowed cases:
+        #
+        # - `ENV['key']` is a receiver of `||=`, e.g. `ENV['X'] ||= y`.
+        # - `ENV['key']` is a receiver of `&&=`, e.g. `ENV['X'] &&= y`.
+        def assigned?(node)
+          return false unless (parent = node.parent)&.assignment?
+
+          lhs, _method, _rhs = *parent
+          node == lhs
+        end
+
+        def or_lhs?(node)
+          return false unless (parent = node.parent)&.or_type?
+
+          parent.lhs == node || parent.parent&.or_type?
+        end
+
+        def new_code(name_node)
+          "ENV.fetch(#{name_node.source}, nil)"
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,17 @@ module RuboCop
     module Style
       # Favor `File.(bin)write` convenience methods.
       #
+      # NOTE: There are different method signatures between `File.write` (class method)
+      # and `File#write` (instance method). The following case will be allowed because
+      # static analysis does not know the contents of the splat argument:
+      #
+      # [source,ruby]
+      # ----
+      # File.open(filename, 'w') do |f|
+      #   f.write(*objects)
+      # end
+      # ----
+      #
       # @example
       #   ## text mode
       #   # bad
@@ -85,6 +96,7 @@ module RuboCop
           content = send_write?(node) || block_write?(node) do |block_arg, lvar, write_arg|
             write_arg if block_arg == lvar
           end
+          return false if content&.splat_type?
 
           yield(content) if content
         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/format_string_token.rb

@@ -12,6 +12,7 @@ module RuboCop
       # to encoded URLs or Date/Time formatting strings.
       #
       # This cop can be customized ignored methods with `IgnoredMethods`.
+      # By default, there are no methods to ignored.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -61,6 +62,11 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
+      # @example IgnoredMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
       # @example IgnoredMethods: [redirect]
       #
       #   # good
@@ -69,6 +75,7 @@ module RuboCop
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        extend AutoCorrector
 
         def on_str(node)
           return if format_string_token?(node) || use_ignored_method?(node)
@@ -77,13 +84,8 @@ module RuboCop
           return if detections.empty?
           return if allowed_unannotated?(detections)
 
-          detections.each do |detected_style, token_range|
-            if detected_style == style
-              correct_style_detected
-            else
-              style_detected(detected_style)
-              add_offense(token_range, message: message(detected_style))
-            end
+          detections.each do |detected_sequence, token_range|
+            check_sequence(detected_sequence, token_range)
           end
         end
 
@@ -106,6 +108,38 @@ module RuboCop
           send_parent && ignored_method?(send_parent.method_name)
         end
 
+        def check_sequence(detected_sequence, token_range)
+          if detected_sequence.style == style
+            correct_style_detected
+          elsif correctable_sequence?(detected_sequence.type)
+            style_detected(detected_sequence.style)
+            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+              autocorrect_sequence(corrector, detected_sequence, token_range)
+            end
+          end
+        end
+
+        def correctable_sequence?(detected_type)
+          detected_type == 's' || style == :annotated || style == :unannotated
+        end
+
+        def autocorrect_sequence(corrector, detected_sequence, token_range)
+          return if style == :unannotated
+
+          name = detected_sequence.name
+          return if name.nil?
+
+          flags = detected_sequence.flags
+          width = detected_sequence.width
+          precision = detected_sequence.precision
+          type = detected_sequence.style == :template ? 's' : detected_sequence.type
+          correction = case style
+                       when :annotated then "%<#{name}>#{flags}#{width}#{precision}#{type}"
+                       when :template then "%#{flags}#{width}#{precision}{#{name}}"
+                       end
+          corrector.replace(token_range, correction)
+        end
+
         def unannotated_format?(node, detected_style)
           detected_style == :unannotated && !format_string_in_typical_context?(node)
         end
@@ -143,30 +177,33 @@ module RuboCop
         def token_ranges(contents)
           format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-          format_string.format_sequences.each do |seq|
-            next if seq.percent?
+          format_string.format_sequences.each do |detected_sequence|
+            next if detected_sequence.percent?
 
-            detected_style = seq.style
-            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
+            token = contents.begin.adjust(begin_pos: detected_sequence.begin_pos,
+                                          end_pos: detected_sequence.end_pos)
 
-            yield(detected_style, token)
+            yield(detected_sequence, token)
           end
         end
 
         def collect_detections(node)
           detections = []
-          tokens(node) do |detected_style, token_range|
-            unless unannotated_format?(node, detected_style)
-              detections << [detected_style, token_range]
+          tokens(node) do |detected_sequence, token_range|
+            unless unannotated_format?(node, detected_sequence.style)
+              detections << [detected_sequence, token_range]
             end
           end
           detections
         end
 
         def allowed_unannotated?(detections)
-          return false if detections.size > max_unannotated_placeholders_allowed
+          return false unless detections.all? do |detected_sequence,|
+                                detected_sequence.style == :unannotated
+                              end
+          return true if detections.size <= max_unannotated_placeholders_allowed
 
-          detections.all? { |detected_style,| detected_style == :unannotated }
+          detections.any? { |detected_sequence,| !correctable_sequence?(detected_sequence.type) }
         end
 
         def max_unannotated_placeholders_allowed

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.'
@@ -179,7 +182,7 @@ module RuboCop
         end
 
         def remove_comment(corrector, node)
-          corrector.remove(range_with_surrounding_space(range: node.pos, side: :right))
+          corrector.remove(range_with_surrounding_space(node.pos, side: :right))
         end
 
         def enable_comment(corrector)

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

@@ -47,6 +47,37 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   if foo?
+      #     work
+      #   end
+      #
+      #   if bar?  # <- reports an offense
+      #     work
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   if foo?
+      #     work
+      #   end
+      #
+      #   if bar?
+      #     work
+      #   end
+      #
+      #   # bad
+      #   if foo?
+      #     work
+      #   end
+      #
+      #   do_something
+      #
+      #   if bar?  # <- reports an offense
+      #     work
+      #   end
       class GuardClause < Base
         include MinBodyLength
         include StatementModifier
@@ -79,7 +110,7 @@ module RuboCop
           kw = if guard_clause_in_if
                  node.loc.keyword.source
                else
-                 opposite_keyword(node)
+                 node.inverse_keyword
                end
 
           register_offense(node, guard_clause_source(guard_clause), kw)
@@ -89,18 +120,26 @@ module RuboCop
 
         def check_ending_if(node)
           return if accepted_form?(node, ending: true) || !min_body_length?(node)
+          return if allowed_consecutive_conditionals? &&
+                    consecutive_conditionals?(node.parent, node)
 
-          register_offense(node, 'return', opposite_keyword(node))
+          register_offense(node, 'return', node.inverse_keyword)
         end
 
-        def opposite_keyword(node)
-          node.if? ? 'unless' : 'if'
+        def consecutive_conditionals?(parent, node)
+          parent.each_child_node.inject(false) do |if_type, child|
+            break if_type if node == child
+
+            child.if_type?
+          end
         end
 
         def register_offense(node, scope_exiting_keyword, conditional_keyword)
           condition, = node.node_parts
           example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
+            return if trivial?(node)
+
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
           end
 
@@ -126,6 +165,10 @@ module RuboCop
           accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
+        def trivial?(node)
+          node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
+        end
+
         def accepted_if?(node, ending)
           return true if node.modifier_form? || node.ternary?
 
@@ -135,6 +178,10 @@ module RuboCop
             !node.else? || node.elsif?
           end
         end
+
+        def allowed_consecutive_conditionals?
+          cop_config.fetch('AllowConsecutiveConditionals', false)
+        end
       end
     end
   end

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

@@ -87,7 +87,7 @@ module RuboCop
 
         def remove_last_element_trailing_comma(corrector, node)
           range = range_with_surrounding_space(
-            range: node.children.last.source_range,
+            node.children.last.source_range,
             side: :right
           ).end.resize(1)
 

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.
@@ -19,6 +19,9 @@ module RuboCop
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) }
       #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
@@ -33,15 +36,36 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
-        # @!method bad_method?(node)
-        def_node_matcher :bad_method?, <<~PATTERN
+        # @!method bad_method_with_poro?(node)
+        def_node_matcher :bad_method_with_poro?, <<~PATTERN
           (block
             (send _ _)
             (args
               (arg _)
               (arg _))
-            (send
-              _ {:== :!= :eql?} _))
+            {
+              (send
+                _ {:== :!= :eql? :include?} _)
+              (send
+                (send
+                  _ {:== :!= :eql? :include?} _) :!)
+              })
+        PATTERN
+
+        # @!method bad_method_with_active_support?(node)
+        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
+          (block
+            (send _ _)
+            (args
+              (arg _)
+              (arg _))
+            {
+              (send
+                _ {:== :!= :eql? :in? :include? :exclude?} _)
+              (send
+                (send
+                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+              })
         PATTERN
 
         def on_send(node)
@@ -52,7 +76,7 @@ module RuboCop
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
-          preferred_method = "except(#{except_key.source})"
+          preferred_method = "except(#{except_key_source(except_key)})"
 
           add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
             corrector.replace(range, preferred_method)
@@ -61,28 +85,84 @@ module RuboCop
 
         private
 
+        def bad_method?(block)
+          if active_support_extensions_enabled?
+            bad_method_with_active_support?(block)
+          else
+            bad_method_with_poro?(block)
+          end
+        end
+
         def semantically_except_method?(send, block)
           body = block.body
 
+          negated = body.method?('!')
+          body = body.receiver if negated
+
           case send.method_name
           when :reject
-            body.method?('==') || body.method?('eql?')
+            body.method?('==') || body.method?('eql?') || included?(negated, body)
           when :select, :filter
-            body.method?('!=')
+            body.method?('!=') || not_included?(negated, body)
           else
             false
           end
         end
 
+        def included?(negated, body)
+          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
+        end
+
+        def not_included?(negated, body)
+          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
+        end
+
         def safe_to_register_offense?(block, except_key)
+          extracted = extract_body_if_nagated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') || \
+             extracted.method?('exclude?')
+            return true
+          end
           return true if block.body.method?('eql?')
 
           except_key.sym_type? || except_key.str_type?
         end
 
+        def extract_body_if_nagated(body)
+          return body unless body.method?('!')
+
+          body.receiver
+        end
+
+        def except_key_source(key)
+          if key.array_type?
+            key = if key.percent_literal?
+                    key.each_value.map { |v| decorate_source(v) }
+                  else
+                    key.each_value.map(&:source)
+                  end
+            return key.join(', ')
+          end
+
+          key.literal? ? key.source : "*#{key.source}"
+        end
+
+        def decorate_source(value)
+          return ":\"#{value.source}\"" if value.dsym_type?
+          return "\"#{value.source}\"" if value.dstr_type?
+          return ":#{value.source}" if value.sym_type?
+
+          "'#{value.source}'"
+        end
+
         def except_key(node)
           key_argument = node.argument_list.first.source
-          lhs, _method_name, rhs = *node.body
+          body = extract_body_if_nagated(node.body)
+          lhs, _method_name, rhs = *body
+
+          return lhs if body.method?('include?')
+          return lhs if body.method?('exclude?')
+          return rhs if body.method?('in?')
           return if [lhs, rhs].map(&:source).none?(key_argument)
 
           [lhs, rhs].find { |operand| operand.source != key_argument }

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)