rubocop 1.9.1 → 1.22.3

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

@@ -1,28 +1,33 @@
 # frozen_string_literal: true
 
-require 'parser/current'
-
 module RuboCop
   module Cop
     module Style
       # This cop checks for a redundant argument passed to certain methods.
       #
-      # Limitations:
-      #
-      # 1. This cop matches for method names only and hence cannot tell apart
-      #    methods with same name in different classes.
-      # 2. This cop is limited to methods with single parameter.
-      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
-      #    That depends on the nature of the target methods, of course.
+      # NOTE: This cop is limited to methods with single parameter.
       #
       # Method names and their redundant arguments can be configured like this:
       #
+      # [source,yaml]
+      # ----
       # Methods:
       #   join: ''
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
       #   foo: 2
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because of the following limitations:
+      #
+      #   1. This cop matches by method names only and hence cannot tell apart
+      #      methods with same name in different classes.
+      #   2. This cop may be unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
+      #      That depends on the nature of the target methods, of course. For example, the default
+      #      argument to join is `$OUTPUT_FIELD_SEPARATOR` (or `$,`) rather than `''`, and if that
+      #      global is changed, `''` is no longer a redundant argument.
       #
       # @example
       #   # bad
@@ -53,8 +58,11 @@ module RuboCop
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
-          add_offense(node, message: format(MSG, arg: node.arguments.first.source)) do |corrector|
-            corrector.remove(argument_range(node))
+          offense_range = argument_range(node)
+          message = format(MSG, arg: node.arguments.first.source)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(offense_range)
           end
         end
 
@@ -68,17 +76,10 @@ module RuboCop
         end
 
         def redundant_arg_for_method(method_name)
-          return nil unless cop_config['Methods'].key?(method_name)
+          arg = cop_config['Methods'].fetch(method_name) { return }
 
           @mem ||= {}
-          @mem[method_name] ||=
-            begin
-              arg = cop_config['Methods'].fetch(method_name)
-              buffer = Parser::Source::Buffer.new('(string)', 1)
-              buffer.source = arg.inspect
-              builder = RuboCop::AST::Builder.new
-              Parser::CurrentRuby.new(builder).parse(buffer)
-            end
+          @mem[method_name] ||= parse(arg.inspect).ast
         end
 
         def argument_range(node)

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

@@ -42,6 +42,7 @@ module RuboCop
 
         MSG = 'Redundant assignment before returning detected.'
 
+        # @!method redundant_assignment?(node)
         def_node_matcher :redundant_assignment?, <<~PATTERN
           (... $(lvasgn _name _expression) (lvar _name))
         PATTERN
@@ -80,9 +81,7 @@ module RuboCop
         end
 
         def check_rescue_node(node)
-          node.child_nodes.each do |child_node|
-            check_branch(child_node)
-          end
+          node.child_nodes.each { |child_node| check_branch(child_node) }
         end
 
         def check_ensure_node(node)

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

@@ -36,7 +36,6 @@ module RuboCop
       #   do_something
       #
       #   # bad
-      #   # When using Ruby 2.5 or later.
       #   do_something do
       #     begin
       #       something
@@ -63,6 +62,7 @@ module RuboCop
       #     end
       #   end
       class RedundantBegin < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant `begin` block detected.'
@@ -75,8 +75,6 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return if target_ruby_version < 2.5
-
           return if node.send_node.lambda_literal?
           return if node.braces?
           return unless node.body&.kwbegin_type?
@@ -85,7 +83,10 @@ module RuboCop
         end
 
         def on_kwbegin(node)
-          return if contain_rescue_or_ensure?(node) || valid_context_using_only_begin?(node)
+          return if empty_begin?(node) ||
+                    begin_block_has_multiline_statements?(node) ||
+                    contain_rescue_or_ensure?(node) ||
+                    valid_context_using_only_begin?(node)
 
           register_offense(node)
         end
@@ -93,12 +94,68 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(node.loc.begin) do |corrector|
-            corrector.remove(node.loc.begin)
+          offense_range = node.loc.begin
+
+          add_offense(offense_range) do |corrector|
+            if any_ancestor_assignment_node?(node)
+              replace_begin_with_statement(corrector, offense_range, node)
+            else
+              corrector.remove(offense_range)
+            end
+
+            if use_modifier_form_after_multiline_begin_block?(node)
+              correct_modifier_form_after_multiline_begin_block(corrector, node)
+            end
             corrector.remove(node.loc.end)
           end
         end
 
+        def replace_begin_with_statement(corrector, offense_range, node)
+          first_child = node.children.first
+
+          source = first_child.source
+          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+
+          corrector.replace(offense_range, source)
+          corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
+
+          restore_removed_comments(corrector, offense_range, node, first_child)
+        end
+
+        # Restore comments that occur between "begin" and "first_child".
+        # These comments will be moved to above the assignment line.
+        def restore_removed_comments(corrector, offense_range, node, first_child)
+          comments_range = range_between(offense_range.end_pos, first_child.source_range.begin_pos)
+          comments = comments_range.source
+
+          corrector.insert_before(node.parent, comments) unless comments.blank?
+        end
+
+        def use_modifier_form_after_multiline_begin_block?(node)
+          return unless (parent = node.parent)
+
+          node.multiline? && parent.if_type? && parent.modifier_form?
+        end
+
+        def correct_modifier_form_after_multiline_begin_block(corrector, node)
+          condition_range = condition_range(node.parent)
+
+          corrector.insert_after(node.children.first, " #{condition_range.source}")
+          corrector.remove(range_by_whole_lines(condition_range, include_final_newline: true))
+        end
+
+        def condition_range(node)
+          range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+        end
+
+        def empty_begin?(node)
+          node.children.empty?
+        end
+
+        def begin_block_has_multiline_statements?(node)
+          node.children.count >= 2
+        end
+
         def contain_rescue_or_ensure?(node)
           first_child = node.children.first
 
@@ -108,9 +165,17 @@ module RuboCop
         def valid_context_using_only_begin?(node)
           parent = node.parent
 
-          node.each_ancestor.any?(&:assignment?) || parent&.post_condition_loop? ||
+          valid_begin_assignment?(node) || parent&.post_condition_loop? ||
             parent&.send_type? || parent&.operator_keyword?
         end
+
+        def valid_begin_assignment?(node)
+          any_ancestor_assignment_node?(node) && !node.children.one?
+        end
+
+        def any_ancestor_assignment_node?(node)
+          node.each_ancestor.any?(&:assignment?)
+        end
       end
     end
   end

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

@@ -18,8 +18,7 @@ module RuboCop
         include PercentLiteral
         extend AutoCorrector
 
-        MSG = 'Do not use `%W` unless interpolation is needed. ' \
-              'If not, use `%w`.'
+        MSG = 'Do not use `%W` unless interpolation is needed. If not, use `%w`.'
 
         def on_array(node)
           process(node, '%W')

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

@@ -78,9 +78,7 @@ module RuboCop
           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?
+            node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?
           )
         end
 
@@ -104,8 +102,7 @@ module RuboCop
 
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_branch.source,
-                          else_source(else_branch)].join(' || ')
+          ternary_form = [if_branch.source, else_source(else_branch)].join(' || ')
 
           if node.parent&.send_type?
             "(#{ternary_form})"
@@ -123,11 +120,10 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.basic_conditional? &&
-            node.modifier_form? ||
+          (node.basic_conditional? && node.modifier_form?) ||
             node.range_type? ||
             node.rescue_type? ||
-            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
         def without_argument_parentheses_method?(node)

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

@@ -31,8 +31,7 @@ module RuboCop
         operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
         COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
 
-        MSG = 'This conditional expression can just be replaced ' \
-              'by `%<msg>s`.'
+        MSG = 'This conditional expression can just be replaced by `%<msg>s`.'
 
         def on_if(node)
           return unless offense?(node)
@@ -53,10 +52,12 @@ module RuboCop
           format(MSG, msg: msg)
         end
 
+        # @!method redundant_condition?(node)
         def_node_matcher :redundant_condition?, <<~RUBY
           (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
         RUBY
 
+        # @!method redundant_condition_inverted?(node)
         def_node_matcher :redundant_condition_inverted?, <<~RUBY
           (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) false true)
         RUBY
@@ -76,11 +77,9 @@ module RuboCop
 
         def invert_expression?(node)
           (
-            (node.if? || node.elsif? || node.ternary?) &&
-            redundant_condition_inverted?(node)
+            (node.if? || node.elsif? || node.ternary?) && redundant_condition_inverted?(node)
           ) || (
-            node.unless? &&
-            redundant_condition?(node)
+            node.unless? && redundant_condition?(node)
           )
         end
 

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

@@ -20,8 +20,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG_1 = 'Redundant `RuntimeError` argument can be removed.'
-        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
-                'just the message.'
+        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with just the message.'
 
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
@@ -35,11 +34,9 @@ module RuboCop
           exploded?(node) do |command, message|
             add_offense(node, message: MSG_1) do |corrector|
               if node.parenthesized?
-                corrector.replace(node,
-                                  "#{command}(#{message.source})")
+                corrector.replace(node, "#{command}(#{message.source})")
               else
-                corrector.replace(node,
-                                  "#{command} #{message.source}")
+                corrector.replace(node, "#{command} #{message.source}")
               end
             end
           end
@@ -53,10 +50,12 @@ module RuboCop
           end
         end
 
+        # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
           (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
+        # @!method compact?(node)
         def_node_matcher :compact?, <<~PATTERN
           (send nil? {:raise :fail} $(send (const {nil? cbase} :RuntimeError) :new $_))
         PATTERN

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

@@ -9,6 +9,10 @@ module RuboCop
       # In such cases `fetch(key, value)` method is faster
       # than `fetch(key) { value }`.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   does not have a different implementation of `fetch`.
+      #
       # @example SafeForConstants: false (default)
       #   # bad
       #   hash.fetch(:key) { 5 }
@@ -38,6 +42,7 @@ module RuboCop
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
 
+        # @!method redundant_fetch_block_candidate?(node)
         def_node_matcher :redundant_fetch_block_candidate?, <<~PATTERN
           (block
             $(send _ :fetch _)
@@ -78,6 +83,7 @@ module RuboCop
             rails_cache?(send.receiver)
         end
 
+        # @!method rails_cache?(node)
         def_node_matcher :rails_cache?, <<~PATTERN
           (send (const _ :Rails) :cache)
         PATTERN

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

@@ -25,11 +25,13 @@ module RuboCop
       #   require_relative '../foo.so'
       #
       class RedundantFileExtensionInRequire < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant `.rb` file extension detected.'
         RESTRICT_ON_SEND = %i[require require_relative].freeze
 
+        # @!method require_call?(node)
         def_node_matcher :require_call?, <<~PATTERN
           (send nil? {:require :require_relative} $str_type?)
         PATTERN
@@ -38,13 +40,21 @@ module RuboCop
           require_call?(node) do |name_node|
             return unless name_node.value.end_with?('.rb')
 
-            add_offense(name_node) do |corrector|
-              correction = name_node.value.sub(/\.rb\z/, '')
+            extension_range = extension_range(name_node)
 
-              corrector.replace(name_node, "'#{correction}'")
+            add_offense(extension_range) do |corrector|
+              corrector.remove(extension_range)
             end
           end
         end
+
+        private
+
+        def extension_range(name_node)
+          end_of_path_string = name_node.source_range.end_pos
+
+          range_between(end_of_path_string - 4, end_of_path_string - 1)
+        end
       end
     end
   end

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

@@ -7,6 +7,9 @@ module RuboCop
       #
       # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated
+      # string literals when `# frozen-string-literal: true` is used.
+      #
       # @example
       #   # bad
       #   CONST = 1.freeze
@@ -17,8 +20,7 @@ module RuboCop
         extend AutoCorrector
         include FrozenStringLiteral
 
-        MSG = 'Do not freeze immutable objects, as freezing them has no ' \
-              'effect.'
+        MSG = 'Do not freeze immutable objects, as freezing them has no effect.'
         RESTRICT_ON_SEND = %i[freeze].freeze
 
         def on_send(node)
@@ -38,9 +40,7 @@ module RuboCop
           node = strip_parenthesis(node)
 
           return true if node.immutable_literal?
-
-          return true if FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-                         frozen_string_literals_enabled?
+          return true if frozen_string_literal?(node)
 
           target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
         end
@@ -53,12 +53,12 @@ module RuboCop
           end
         end
 
+        # @!method operation_produces_immutable_object?(node)
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
             (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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

@@ -56,7 +56,7 @@ module RuboCop
           first_child = node.children.first
 
           variable_interpolation?(first_child) ||
-            first_child.send_type? && !first_child.operator_method?
+            (first_child.send_type? && !first_child.operator_method?)
         end
 
         def interpolation?(node)
@@ -72,8 +72,7 @@ module RuboCop
         end
 
         def embedded_in_percent_array?(node)
-          node.parent&.array_type? &&
-            percent_literal?(node.parent)
+          node.parent&.array_type? && percent_literal?(node.parent)
         end
 
         def autocorrect_variable_interpolation(corrector, embedded_node, node)

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

@@ -17,13 +17,20 @@ module RuboCop
         include Parentheses
         extend AutoCorrector
 
-        def_node_matcher :square_brackets?,
-                         '(send {(send _recv _msg) str array hash} :[] ...)'
+        # @!method square_brackets?(node)
+        def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
+
+        # @!method range_end?(node)
         def_node_matcher :range_end?, '^^{irange erange}'
+
+        # @!method method_node_and_args(node)
         def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
+
+        # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
-        def_node_matcher :arg_in_call_with_block?,
-                         '^^(block (send _ _ equal?(%0) ...) ...)'
+
+        # @!method arg_in_call_with_block?(node)
+        def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
 
         def on_begin(node)
           return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
@@ -109,6 +116,7 @@ module RuboCop
           check_send(begin_node, node) if node.call_type?
         end
 
+        # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
         def check_send(begin_node, node)
@@ -125,8 +133,7 @@ module RuboCop
 
           node = node.children.first while suspect_unary?(node)
 
-          return if node.send_type? &&
-                    !method_call_with_redundant_parentheses?(node)
+          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
 
           offense(begin_node, 'an unary operation')
         end
@@ -151,16 +158,11 @@ module RuboCop
           # { a: (1
           #      ), }
           # ```
-          (hash_element?(node) || array_element?(node)) &&
-            only_closing_paren_before_comma?(node)
-        end
-
-        def hash_element?(node)
-          node.parent&.pair_type?
+          hash_or_array_element?(node) && only_closing_paren_before_comma?(node)
         end
 
-        def array_element?(node)
-          node.parent&.array_type?
+        def hash_or_array_element?(node)
+          node.each_ancestor(:array, :hash).any?
         end
 
         def only_closing_paren_before_comma?(node)
@@ -171,9 +173,7 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? &&
-            !node.range_type? &&
-            !raised_to_power_negative_numeric?(begin_node, node)
+          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)
@@ -215,19 +215,20 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) ||
-            first_super_argument?(node) ||
-            first_yield_argument?(node)
+          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
         end
 
+        # @!method first_send_argument?(node)
         def_node_matcher :first_send_argument?, <<~PATTERN
           ^(send _ _ equal?(%0) ...)
         PATTERN
 
+        # @!method first_super_argument?(node)
         def_node_matcher :first_super_argument?, <<~PATTERN
           ^(super equal?(%0) ...)
         PATTERN
 
+        # @!method first_yield_argument?(node)
         def_node_matcher :first_yield_argument?, <<~PATTERN
           ^(yield equal?(%0) ...)
         PATTERN

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

@@ -22,8 +22,7 @@ module RuboCop
 
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
-        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
-                      'double quotes'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
         SINGLE_QUOTE = "'"
         QUOTE = '"'
         EMPTY = ''
@@ -66,9 +65,8 @@ module RuboCop
         end
 
         def allowed_percent_q?(node)
-          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
-            node.source.start_with?(PERCENT_CAPITAL_Q) &&
-              acceptable_capital_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
         end
 
         def message(node)

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

@@ -32,7 +32,7 @@ module RuboCop
 
         REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = '.*+?{}()|$'.chars.freeze
         MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
-        '`%<char_class>s` can be replaced with `%<element>s`.'
+                                        '`%<char_class>s` can be replaced with `%<element>s`.'
 
         def on_regexp(node)
           each_redundant_character_class(node) do |loc|

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

@@ -72,10 +72,7 @@ module RuboCop
         end
 
         def delimiter?(node, char)
-          delimiters = [
-            node.loc.begin.source[-1],
-            node.loc.end.source[0]
-          ]
+          delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
           delimiters.include?(char)
         end

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

@@ -71,9 +71,12 @@ module RuboCop
           elsif hash_without_braces?(return_node.first_argument)
             add_braces(corrector, return_node.first_argument)
           end
+          if return_node.splat_argument?
+            first_argument = return_node.first_argument
+            corrector.replace(first_argument, first_argument.source.delete_prefix('*'))
+          end
 
-          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
-                                                 side: :right)
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword, side: :right)
           corrector.remove(keyword)
         end
 
@@ -109,8 +112,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_return_node(node)
-          return if cop_config['AllowMultipleReturnValues'] &&
-                    node.children.size > 1
+          return if cop_config['AllowMultipleReturnValues'] && node.children.size > 1
 
           add_offense(node.loc.keyword, message: message(node)) do |corrector|
             if node.arguments?