rubocop 1.18.0 → 1.56.0

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

@@ -11,7 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
-      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -61,29 +62,41 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
-      # @example IgnoredMethods: [redirect]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: ['redirect']
       #
       #   # good
       #   redirect('foo/%{bar_id}')
       #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
 
         def on_str(node)
-          return if format_string_token?(node) || use_ignored_method?(node)
+          return if format_string_token?(node) || use_allowed_method?(node)
 
           detections = collect_detections(node)
           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
 
@@ -101,8 +114,43 @@ module RuboCop
           !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
         end
 
-        def use_ignored_method?(node)
-          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+        def use_allowed_method?(node)
+          send_parent = node.each_ancestor(:send).first
+          send_parent &&
+            (allowed_method?(send_parent.method_name) ||
+            matches_allowed_pattern?(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)
@@ -142,30 +190,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,23 @@
 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 comment `# frozen_string_literal: true` to the top of
-      # files to enable frozen string literals. Frozen string literals may be
+      # 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`.
+      #
+      # To require a blank line after this comment, please see
+      # `Layout/EmptyLineAfterMagicComment` cop.
+      #
+      # @safety
+      #  This cop's autocorrection is unsafe since any strings mutations will
+      #  change from being accepted to raising `FrozenError`, as all strings
+      #  will become frozen by default, and will need to be manually refactored.
       #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
@@ -75,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.'
@@ -128,14 +142,16 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          token = next_token if Encoding::ENCODING_PATTERN.match?(next_token&.text)
+          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+            token = next_token
+          end
 
           token
         end
 
         def frozen_string_literal_comment(processed_source)
-          processed_source.find_token do |token|
-            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+          processed_source.tokens.find do |token|
+            token.text.start_with?(FROZEN_STRING_LITERAL)
           end
         end
 
@@ -168,7 +184,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,11 +3,15 @@
 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.
       #
+      # @safety
+      #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
+      #   objects, for example.
+      #
       # @example
       #   # bad
       #   STDOUT.puts('hello')

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

@@ -6,6 +6,13 @@ module RuboCop
       # Use a guard clause instead of wrapping the code inside a conditional
       # expression
       #
+      # A condition with an `elsif` or `else` branch is allowed unless
+      # one of `return`, `break`, `next`, `raise`, or `fail` is used
+      # in the body of the conditional expression.
+      #
+      # NOTE: Autocorrect works in most cases except with if-else statements
+      #   that contain logical operators such as `foo || raise('exception')`
+      #
       # @example
       #   # bad
       #   def test
@@ -47,7 +54,47 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?
+      #       work
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     do_something
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
       class GuardClause < Base
+        extend AutoCorrector
+        include RangeHelp
         include MinBodyLength
         include StatementModifier
 
@@ -59,64 +106,141 @@ module RuboCop
 
           return unless body
 
-          if body.if_type?
-            check_ending_if(body)
-          elsif body.begin_type?
-            final_expression = body.children.last
-            check_ending_if(final_expression) if final_expression&.if_type?
-          end
+          check_ending_body(body)
         end
         alias on_defs on_def
 
         def on_if(node)
           return if accepted_form?(node)
 
-          guard_clause_in_if = node.if_branch&.guard_clause?
-          guard_clause_in_else = node.else_branch&.guard_clause?
-          guard_clause = guard_clause_in_if || guard_clause_in_else
-          return unless guard_clause
+          if (guard_clause = node.if_branch&.guard_clause?)
+            kw = node.loc.keyword.source
+            guard = :if
+          elsif (guard_clause = node.else_branch&.guard_clause?)
+            kw = node.inverse_keyword
+            guard = :else
+          else
+            return
+          end
 
-          kw = if guard_clause_in_if
-                 node.loc.keyword.source
-               else
-                 opposite_keyword(node)
-               end
+          guard = nil if and_or_guard_clause?(guard_clause)
 
-          register_offense(node, guard_clause_source(guard_clause), kw)
+          register_offense(node, guard_clause_source(guard_clause), kw, guard)
         end
 
         private
 
+        def check_ending_body(body)
+          return if body.nil?
+
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
+          end
+        end
+
         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', node.inverse_keyword)
 
-          register_offense(node, 'return', opposite_keyword(node))
+          check_ending_body(node.if_branch)
         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)
+        def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = nil)
           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"
+            replacement = <<~RUBY.chomp
+              #{conditional_keyword} #{condition.source}
+                #{scope_exiting_keyword}
+              end
+            RUBY
           end
 
-          add_offense(node.loc.keyword, message: format(MSG, example: example))
+          add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
+            next if node.else? && guard.nil?
+
+            autocorrect(corrector, node, condition, replacement || example, guard)
+          end
         end
 
-        def guard_clause_source(guard_clause)
-          parent = guard_clause.parent
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def autocorrect(corrector, node, condition, replacement, guard)
+          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+
+          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+
+          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
+            autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
+          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
+            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
+          else
+            corrector.remove(node.loc.end)
+            return unless node.else?
+
+            corrector.remove(node.loc.else)
+            corrector.remove(range_of_branch_to_remove(node, guard))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def heredoc?(argument)
+          argument.respond_to?(:heredoc?) && argument.heredoc?
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          return unless node.else?
+
+          remove_whole_lines(corrector, leave_branch.source_range)
+          remove_whole_lines(corrector, node.loc.else)
+          remove_whole_lines(corrector, node.loc.end)
+          remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
+          corrector.insert_after(
+            heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
+          )
+        end
+
+        def range_of_branch_to_remove(node, guard)
+          branch = case guard
+                   when :if then node.if_branch
+                   when :else then node.else_branch
+                   end
+
+          branch.source_range
+        end
 
-          if parent.and_type? || parent.or_type?
+        def guard_clause_source(guard_clause)
+          if and_or_guard_clause?(guard_clause)
             guard_clause.parent.source
           else
             guard_clause.source
           end
         end
 
+        def and_or_guard_clause?(guard_clause)
+          parent = guard_clause.parent
+          parent.and_type? || parent.or_type?
+        end
+
         def too_long_for_single_line?(node, example)
           max = max_line_length
           max && node.source_range.column + example.length > max
@@ -126,8 +250,12 @@ 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?
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional?
 
           if ending
             node.else?
@@ -135,6 +263,14 @@ module RuboCop
             !node.else? || node.elsif?
           end
         end
+
+        def remove_whole_lines(corrector, range)
+          corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        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

@@ -29,10 +29,12 @@ module RuboCop
       #   # good
       #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
+        include RangeHelp
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
         def on_hash(node)
+          return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
           return unless last_array_item?(array, node) && explicit_array?(array)
 
@@ -74,6 +76,7 @@ module RuboCop
           return if node.children.empty? # Empty hash cannot be "unbraced"
 
           add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            remove_last_element_trailing_comma(corrector, node.parent)
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
@@ -82,6 +85,15 @@ module RuboCop
         def braces_style?
           style == :braces
         end
+
+        def remove_last_element_trailing_comma(corrector, node)
+          range = range_with_surrounding_space(
+            node.children.last.source_range,
+            side: :right
+          ).end.resize(1)
+
+          corrector.remove(range) if range.source == ','
+        end
       end
     end
   end

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

@@ -3,13 +3,23 @@
 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,
       # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
       # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `ArgumentError` occurs
+      #   if the number of elements is odd:
+      #
+      #   [source,ruby]
+      #   ----
+      #   Hash[[[1, 2], [3]]] #=> {1=>2, 3=>nil}
+      #   [[1, 2], [5]].to_h  #=> wrong array length at 1 (expected 2, was 1) (ArgumentError)
+      #   ----
+      #
       # @example
       #   # bad
       #   Hash[ary]
@@ -101,7 +111,8 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          node.call_type? && node.arguments.any? && !node.parenthesized?
+          (node.call_type? && node.arguments.any? && !node.parenthesized?) ||
+            node.or_type? || node.and_type?
         end
 
         def multi_argument(node)

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

@@ -3,12 +3,17 @@
 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
       #   working with a hash, and suppress RuboCop offenses.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash`. The `AllowedReceivers` configuration can mitigate,
+      #   but not fully resolve, this safety issue.
+      #
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }
@@ -23,6 +28,7 @@ module RuboCop
       #   execute(sql).keys.each { |v| p v }
       #   execute(sql).values.each { |v| p v }
       class HashEachMethods < Base
+        include AllowedReceivers
         include Lint::UnusedArgument
         extend AutoCorrector
 
@@ -30,29 +36,53 @@ module RuboCop
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          (block $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method kv_each_with_block_pass(node)
+        def_node_matcher :kv_each_with_block_pass, <<~PATTERN
+          (send $(send _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
         def on_block(node)
-          register_kv_offense(node)
+          kv_each(node) do |target, method|
+            register_kv_offense(target, method)
+          end
+        end
+
+        alias on_numblock on_block
+
+        def on_block_pass(node)
+          kv_each_with_block_pass(node.parent) do |target, method|
+            register_kv_with_block_pass_offense(node, target, method)
+          end
         end
 
         private
 
-        def register_kv_offense(node)
-          kv_each(node) do |target, method|
-            parent_receiver = target.receiver.receiver
-            return unless parent_receiver
-            return if allowed_receiver?(parent_receiver)
+        def register_kv_offense(target, method)
+          return unless (parent_receiver = target.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
 
-            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
+          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+            correct_key_value_each(target, corrector)
+          end
+        end
+
+        def register_kv_with_block_pass_offense(node, target, method)
+          return unless (parent_receiver = node.parent.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
 
-            add_offense(kv_range(target), message: msg) do |corrector|
-              correct_key_value_each(target, corrector)
-            end
+          range = target.loc.selector.with(end_pos: node.parent.loc.selector.end_pos)
+          add_offense(range, message: format_message(method)) do |corrector|
+            corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
+        def format_message(method_name)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: "#{method_name}.each")
+        end
+
         def check_argument(variable)
           return unless variable.block_argument?
 
@@ -87,16 +117,6 @@ module RuboCop
         def kv_range(outer_node)
           outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
-
-        def allowed_receiver?(receiver)
-          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
-
-          allowed_receivers.include?(receiver_name)
-        end
-
-        def allowed_receivers
-          cop_config.fetch('AllowedReceivers', [])
-        end
       end
     end
   end