rubocop 1.50.2 → 1.68.0

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

@@ -95,6 +95,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowedMethods: ['method_missing', 'respond_to_missing?']
+      #
+      #    # good
+      #    class Foo
+      #      def method_missing(name, *args)
+      #      end
+      #
+      #      def respond_to_missing?(symbol, include_private)
+      #      end
+      #    end
+      #
       class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
@@ -119,6 +130,7 @@ module RuboCop
         def check(node)
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
+          return if method_allowed?(node)
 
           add_offense(node)
         end
@@ -126,6 +138,14 @@ module RuboCop
         def require_for_non_public_methods?
           cop_config['RequireForNonPublicMethods']
         end
+
+        def method_allowed?(node)
+          allowed_methods.include?(node.method_name)
+        end
+
+        def allowed_methods
+          @allowed_methods ||= cop_config.fetch('AllowedMethods', []).map(&:to_sym)
+        end
       end
     end
   end

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

@@ -16,7 +16,6 @@ module RuboCop
       #   # good
       #   5.times { }
       #
-      # @example
       #   # bad
       #   (0...10).each {}
       #
@@ -32,27 +31,27 @@ module RuboCop
 
           send_node = node.send_node
 
-          range = send_node.receiver.source_range.join(send_node.loc.selector)
-
-          add_offense(range) do |corrector|
+          add_offense(send_node) do |corrector|
             range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node, "#{max - min}.times")
+            corrector.replace(send_node, "#{max - min}.times")
           end
         end
 
         private
 
         def offending?(node)
+          return false unless node.arguments.empty?
+
           each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
         end
 
         # @!method each_range(node)
         def_node_matcher :each_range, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 (${irange erange}
                   (int $_) (int $_)))
@@ -64,7 +63,7 @@ module RuboCop
         # @!method each_range_with_zero_origin?(node)
         def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 ({irange erange}
                   (int 0) (int _)))
@@ -76,7 +75,7 @@ module RuboCop
         # @!method each_range_without_block_argument?(node)
         def_node_matcher :each_range_without_block_argument?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 ({irange erange}
                   (int _) (int _)))

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

@@ -58,12 +58,12 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $_ $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
         def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
-          (numblock $(send _ {:inject :reduce} _) 2 $_)
+          (numblock $(call _ {:inject :reduce} _) 2 $_)
         PATTERN
 
         def autocorrect_block(corrector, node, return_value)

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

@@ -40,9 +40,13 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
-          return if case_node.condition
+          if case_node.condition || NOT_SUPPORTED_PARENT_TYPES.include?(case_node.parent&.type)
+            return
+          end
 
           branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
@@ -52,6 +56,7 @@ module RuboCop
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 

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

@@ -143,7 +143,7 @@ module RuboCop
         private
 
         def check(node)
-          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+          return if cop_config['AllowComments'] && comment_in_else?(node)
 
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
@@ -171,16 +171,17 @@ module RuboCop
 
         def autocorrect(corrector, node)
           return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node.loc)
+          return false if comment_in_else?(node)
 
           end_pos = base_node(node).loc.end.begin_pos
           corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
         end
 
-        def comment_in_else?(loc)
-          return false if loc.else.nil? || loc.end.nil?
+        def comment_in_else?(node)
+          node = node.parent while node.if_type? && node.elsif?
+          return false unless node.else?
 
-          processed_source.contains_comment?(loc.else.join(loc.end))
+          processed_source.contains_comment?(node.loc.else.join(node.source_range.end))
         end
 
         def base_node(node)

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

@@ -36,6 +36,7 @@ module RuboCop
       class EmptyHeredoc < Base
         include Heredoc
         include RangeHelp
+        include StringLiteralsHelp
         extend AutoCorrector
 
         MSG = 'Use an empty string literal instead of heredoc.'
@@ -53,20 +54,6 @@ module RuboCop
             corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
           end
         end
-
-        private
-
-        def preferred_string_literal
-          enforce_double_quotes? ? '""' : "''"
-        end
-
-        def enforce_double_quotes?
-          string_literals_config['EnforcedStyle'] == 'double_quotes'
-        end
-
-        def string_literals_config
-          config.for_cop('Style/StringLiterals')
-        end
       end
     end
   end

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

@@ -9,7 +9,9 @@ module RuboCop
       # @example
       #   # bad
       #   a = Array.new
+      #   a = Array[]
       #   h = Hash.new
+      #   h = Hash[]
       #   s = String.new
       #
       #   # good
@@ -19,16 +21,17 @@ module RuboCop
       class EmptyLiteral < Base
         include FrozenStringLiteral
         include RangeHelp
+        include StringLiteralsHelp
         extend AutoCorrector
 
-        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
-        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
+        ARR_MSG = 'Use array literal `[]` instead of `%<current>s`.'
+        HASH_MSG = 'Use hash literal `{}` instead of `%<current>s`.'
         STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
-        RESTRICT_ON_SEND = %i[new].freeze
+        RESTRICT_ON_SEND = %i[new [] Array Hash].freeze
 
         # @!method array_node(node)
-        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new (array)?)'
 
         # @!method hash_node(node)
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
@@ -47,6 +50,22 @@ module RuboCop
           }
         PATTERN
 
+        # @!method array_with_index(node)
+        def_node_matcher :array_with_index, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Array) :[])
+            (send nil? :Array (array))
+          }
+        PATTERN
+
+        # @!method hash_with_index(node)
+        def_node_matcher :hash_with_index, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Hash) :[])
+            (send nil? :Hash (array))
+          }
+        PATTERN
+
         def on_send(node)
           return unless (message = offense_message(node))
 
@@ -59,31 +78,19 @@ module RuboCop
 
         def offense_message(node)
           if offense_array_node?(node)
-            ARR_MSG
+            format(ARR_MSG, current: node.source)
           elsif offense_hash_node?(node)
-            HASH_MSG
+            format(HASH_MSG, current: node.source)
           elsif str_node(node) && !frozen_strings?
             format(STR_MSG, prefer: preferred_string_literal)
           end
         end
 
-        def preferred_string_literal
-          enforce_double_quotes? ? '""' : "''"
-        end
-
-        def enforce_double_quotes?
-          string_literals_config['EnforcedStyle'] == 'double_quotes'
-        end
-
-        def string_literals_config
-          config.for_cop('Style/StringLiterals')
-        end
-
         def first_argument_unparenthesized?(node)
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
+          node.equal?(parent.first_argument) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
@@ -100,12 +107,12 @@ module RuboCop
         end
 
         def offense_array_node?(node)
-          array_node(node) && !array_with_block(node.parent)
+          (array_node(node) && !array_with_block(node.parent)) || array_with_index(node)
         end
 
         def offense_hash_node?(node)
           # If Hash.new takes a block, it can't be changed to {}.
-          hash_node(node) && !hash_with_block(node.parent)
+          (hash_node(node) && !hash_with_block(node.parent)) || hash_with_index(node)
         end
 
         def correction(node)
@@ -129,8 +136,10 @@ module RuboCop
         def frozen_strings?
           return true if frozen_string_literals_enabled?
 
-          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteral')['Enabled']
-          frozen_string_cop_enabled && !frozen_string_literals_disabled?
+          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteralComment')['Enabled']
+          frozen_string_cop_enabled &&
+            !frozen_string_literals_disabled? &&
+            string_literals_frozen_by_default?.nil?
         end
       end
     end

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

@@ -48,6 +48,7 @@ module RuboCop
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
+        include EndlessMethodRewriter
         extend TargetRubyVersion
         extend AutoCorrector
 
@@ -81,20 +82,6 @@ module RuboCop
 
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
-
-        def correct_to_multiline(corrector, node)
-          replacement = <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)}
-              #{node.body.source}
-            end
-          RUBY
-
-          corrector.replace(node, replacement)
-        end
-
-        def arguments(node, missing = '')
-          node.arguments.any? ? node.arguments.source : missing
-        end
       end
     end
   end

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Style
       # 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
+      # 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
       # in a backtrace.
       #
-      # The cop also checks that the line number given relative to `__LINE__` is
+      # The cop also checks that the line number given relative to `\_\_LINE\_\_` is
       # correct.
       #
       # This cop will autocorrect incorrect or missing filename and line number
@@ -17,6 +17,18 @@ module RuboCop
       # will not attempt to automatically add a binding, or add filename and
       # line values.
       #
+      # NOTE: This cop works only when a string literal is given as a code string.
+      # No offense is reported if a string variable is given as below:
+      #
+      # [source,ruby]
+      # ----
+      # code = <<-RUBY
+      #   def do_something
+      #   end
+      # RUBY
+      # eval code # not checked.
+      # ----
+      #
       # @example
       #   # bad
       #   eval <<-RUBY
@@ -42,22 +54,11 @@ module RuboCop
       #     end
       #   RUBY
       #
-      # This cop works only when a string literal is given as a code string.
-      # No offense is reported if a string variable is given as below:
-      #
-      # @example
-      #   # not checked
-      #   code = <<-RUBY
-      #     def do_something
-      #     end
-      #   RUBY
-      #   eval code
-      #
       class EvalWithLocation < Base
         extend AutoCorrector
 
         MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
-        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__`, and `__LINE__` to `eval`.'
         MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
                              'use `%<expected>s` instead of `%<actual>s`.'
         MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
@@ -84,7 +85,7 @@ module RuboCop
           # are considered.
           return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
 
-          code = node.arguments.first
+          code = node.first_argument
           return unless code && (code.str_type? || code.dstr_type?)
 
           check_location(node, code)
@@ -128,17 +129,6 @@ module RuboCop
           node.method?(:eval) ? node.arguments.size >= 2 : true
         end
 
-        # FIXME: It's a Style/ConditionalAssignment's false positive.
-        # rubocop:disable Style/ConditionalAssignment
-        def with_lineno?(node)
-          if node.method?(:eval)
-            node.arguments.size == 4
-          else
-            node.arguments.size == 3
-          end
-        end
-        # rubocop:enable Style/ConditionalAssignment
-
         def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
           expected = expected_line(sign, line_diff)
           message = format(MSG_INCORRECT_LINE,
@@ -146,13 +136,13 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.source_range, message: message) do |corrector|
+          add_offense(line_node, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end
 
         def check_file(node, file_node)
-          return true if special_file_keyword?(file_node)
+          return if special_file_keyword?(file_node)
 
           message = format(MSG_INCORRECT_FILE,
                            method_name: node.method_name,
@@ -165,7 +155,9 @@ module RuboCop
         end
 
         def check_line(node, code)
-          line_node = node.arguments.last
+          line_node = node.last_argument
+          return if line_node.variable? || (line_node.send_type? && !line_node.method?(:+))
+
           line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)
@@ -210,7 +202,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.source_range.end, ", #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
           end
         end
 
@@ -227,7 +219,7 @@ module RuboCop
         end
 
         def missing_line(node, code)
-          line_diff = line_difference(node.arguments.last, code)
+          line_diff = line_difference(node.last_argument, code)
           sign = line_diff.positive? ? :+ : :-
           expected_line(sign, line_diff)
         end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for exact regexp match inside Regexp literals.
+      #
+      # @example
+      #
+      #   # bad
+      #   string =~ /\Astring\z/
+      #   string === /\Astring\z/
+      #   string.match(/\Astring\z/)
+      #   string.match?(/\Astring\z/)
+      #
+      #   # good
+      #   string == 'string'
+      #
+      #   # bad
+      #   string !~ /\Astring\z/
+      #
+      #   # good
+      #   string != 'string'
+      #
+      class ExactRegexpMatch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+
+        # @!method exact_regexp_match(node)
+        def_node_matcher :exact_regexp_match, <<~PATTERN
+          (call
+            _ {:=~ :=== :!~ :match :match?}
+            (regexp
+              (str $_)
+              (regopt)))
+        PATTERN
+
+        def on_send(node)
+          return unless (receiver = node.receiver)
+          return unless (regexp = exact_regexp_match(node))
+
+          parsed_regexp = Regexp::Parser.parse(regexp)
+          return unless exact_match_pattern?(parsed_regexp)
+
+          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def exact_match_pattern?(parsed_regexp)
+          tokens = parsed_regexp.map(&:token)
+          return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos
+
+          !parsed_regexp[1].quantifier
+        end
+
+        def new_method(node)
+          node.method?(:!~) ? '!=' : '=='
+        end
+      end
+    end
+  end
+end

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

@@ -86,7 +86,7 @@ module RuboCop
 
         def extract_block_name(def_node)
           if def_node.block_argument?
-            def_node.arguments.last.name
+            def_node.last_argument.name
           else
             'block'
           end
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def insert_argument(node, corrector, block_name)
-          last_arg = node.arguments.last
+          last_arg = node.last_argument
           arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
           replacement = " &#{block_name}"
           replacement = ",#{replacement}" unless arg_range.source.end_with?(',')

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

@@ -6,8 +6,7 @@ module RuboCop
       # Favor `File.(bin)read` convenience methods.
       #
       # @example
-      #   ## text mode
-      #   # bad
+      #   # bad - text mode
       #   File.open(filename).read
       #   File.open(filename, &:read)
       #   File.open(filename) { |f| f.read }
@@ -23,9 +22,7 @@ module RuboCop
       #   # good
       #   File.read(filename)
       #
-      # @example
-      #   ## binary mode
-      #   # bad
+      #   # bad - binary mode
       #   File.open(filename, 'rb').read
       #   File.open(filename, 'rb', &:read)
       #   File.open(filename, 'rb') do |f|
@@ -63,7 +60,7 @@ module RuboCop
 
         # @!method block_read?(node)
         def_node_matcher :block_read?, <<~PATTERN
-          (block _ (args (arg $_)) (send (lvar $_) :read))
+          (block _ (args (arg _name)) (send (lvar _name) :read))
         PATTERN
 
         def on_send(node)
@@ -100,7 +97,7 @@ module RuboCop
         def file_open_read?(node)
           return true if send_read?(node)
 
-          block_read?(node) { |block_arg, read_lvar| block_arg == read_lvar }
+          block_read?(node)
         end
 
         def read_method(mode)

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

@@ -17,8 +17,7 @@ module RuboCop
       # ----
       #
       # @example
-      #   ## text mode
-      #   # bad
+      #   # bad - text mode
       #   File.open(filename, 'w').write(content)
       #   File.open(filename, 'w') do |f|
       #     f.write(content)
@@ -27,9 +26,7 @@ module RuboCop
       #   # good
       #   File.write(filename, content)
       #
-      # @example
-      #   ## binary mode
-      #   # bad
+      #   # bad - binary mode
       #   File.open(filename, 'wb').write(content)
       #   File.open(filename, 'wb') do |f|
       #     f.write(content)

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

@@ -66,6 +66,8 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
+            return unless node.receiver
+
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
               opposite_style_detected
@@ -80,7 +82,7 @@ module RuboCop
         private
 
         def suspect_enumerable?(node)
-          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
       end
     end