rubocop 1.41.1 → 1.57.1

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

@@ -218,11 +218,9 @@ module RuboCop
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
-        INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
         MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
-        WIDTH = 'Width'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
@@ -352,7 +350,7 @@ module RuboCop
         end
 
         def ternary_condition?(node)
-          [node, node.children.first].any? { |n| n.if_type? && n.ternary? }
+          [node, node.children.first].compact.any? { |n| n.if_type? && n.ternary? }
         end
 
         def lhs_all_match?(branches)
@@ -363,7 +361,7 @@ module RuboCop
         end
 
         def assignment_types_match?(*nodes)
-          return unless assignment_type?(nodes.first)
+          return false unless assignment_type?(nodes.first)
 
           nodes.map(&:type).uniq.one?
         end
@@ -388,7 +386,7 @@ module RuboCop
         def allowed_statements?(branches)
           return false unless branches.all?
 
-          statements = branches.map { |branch| tail(branch) }.compact
+          statements = branches.filter_map { |branch| tail(branch) }
 
           lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
             assignment_types_match?(*statements)
@@ -428,10 +426,6 @@ module RuboCop
           config.for_cop(LINE_LENGTH)[MAX]
         end
 
-        def indentation_width
-          config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
@@ -446,6 +440,8 @@ module RuboCop
       module ConditionalCorrectorHelper
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
+            next if child.source_range.nil?
+
             white_space = white_space_range(child, column)
             corrector.remove(white_space) if white_space.source.strip.empty?
           end
@@ -456,7 +452,7 @@ module RuboCop
         end
 
         def white_space_range(node, column)
-          expression = node.loc.expression
+          expression = node.source_range
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
           Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
@@ -464,9 +460,9 @@ module RuboCop
 
         def assignment(node)
           *_, condition = *node
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    condition.loc.expression.begin_pos)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.source_range.begin_pos,
+                                    condition.source_range.begin_pos)
         end
 
         def correct_if_branches(corrector, cop, node)
@@ -571,7 +567,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 
@@ -622,7 +618,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 

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

@@ -8,8 +8,11 @@ module RuboCop
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml. The default can be changed as follows:
       #
-      #  Style/Copyright:
-      #    Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # [source,yaml]
+      # ----
+      # Style/Copyright:
+      #   Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # ----
       #
       # This regex string is treated as an unanchored regex. For each file
       # that RuboCop scans, a comment that matches this regex must be found or
@@ -82,7 +85,7 @@ module RuboCop
         def notice_found?(processed_source)
           notice_found = false
           notice_regexp = Regexp.new(notice)
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             break unless token.comment?
 
             notice_found = notice_regexp.match?(token.text)

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
+      #
+      # @example
+      #   # bad
+      #   class Person < Data.define(:first_name, :last_name)
+      #     def age
+      #       42
+      #     end
+      #   end
+      #
+      #   # good
+      #   Person = Data.define(:first_name, :last_name) do
+      #     def age
+      #       42
+      #     end
+      #   end
+      class DataInheritance < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't extend an instance initialized by `Data.define`. " \
+              'Use a block to customize the class.'
+
+        minimum_target_ruby_version 3.2
+
+        def on_class(node)
+          return unless data_define?(node.parent_class)
+
+          add_offense(node.parent_class.source_range) do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
+        # @!method data_define?(node)
+        def_node_matcher :data_define?, <<~PATTERN
+          {(send (const {nil? cbase} :Data) :define ...)
+           (block (send (const {nil? cbase} :Data) :define ...) ...)}
+        PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
+          elsif (class_node = parent.parent).body.nil?
+            corrector.remove(range_for_empty_class_body(class_node, parent))
+          else
+            corrector.insert_after(parent, ' do')
+          end
+        end
+
+        def range_for_empty_class_body(class_node, data_define)
+          if class_node.single_line?
+            range_between(data_define.source_range.end_pos, class_node.source_range.end_pos)
+          else
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for places where the `#__dir__` method can replace more
+      # Checks for places where the `#\_\_dir\_\_` method can replace more
       # complex constructs to retrieve a canonicalized absolute path to the
       # current file.
       #

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `Dir.empty?('path/to/dir')` when checking if a directory is empty.
+      #
+      # @example
+      #   # bad
+      #   Dir.entries('path/to/dir').size == 2
+      #   Dir.children('path/to/dir').empty?
+      #   Dir.children('path/to/dir').size == 0
+      #   Dir.each_child('path/to/dir').none?
+      #
+      #   # good
+      #   Dir.empty?('path/to/dir')
+      #
+      class DirEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[== != > empty? none?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send (send (send $(const {nil? cbase} :Dir) :entries $_) :size) {:== :!= :>} (int 2))
+            (send (send (send $(const {nil? cbase} :Dir) :children $_) :size) {:== :!= :>} (int 0))
+            (send (send $(const {nil? cbase} :Dir) :children $_) :empty?)
+            (send (send $(const {nil? cbase} :Dir) :each_child $_) :none?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
+            add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          '!' if %i[!= >].include? node.method_name
+        end
+      end
+    end
+  end
+end

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

@@ -34,8 +34,8 @@ module RuboCop
         extend AutoCorrector
 
         # rubocop:enable Lint/RedundantCopDisableDirective
-        MSG = 'Rubocop disable/enable directives are not permitted.'
-        MSG_FOR_COPS = 'Rubocop disable/enable directives for %<cops>s are not permitted.'
+        MSG = 'RuboCop disable/enable directives are not permitted.'
+        MSG_FOR_COPS = 'RuboCop disable/enable directives for %<cops>s are not permitted.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|

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

@@ -108,15 +108,15 @@ module RuboCop
           comments = heredoc_comment_blocks(arg_node.loc.heredoc_body.line_span)
                      .concat(preceding_comment_blocks(arg_node.parent))
 
-          return if comments.none?
+          return false if comments.none?
 
           regexp = comment_regexp(arg_node)
-          comments.any? { |comment| regexp.match?(comment) } || regexp.match?(comments.join)
+          comments.any?(regexp) || regexp.match?(comments.join)
         end
 
         def preceding_comment_blocks(node)
           # Collect comments in the method call, but outside the heredoc
-          comments = processed_source.each_comment_in_lines(node.loc.expression.line_span)
+          comments = processed_source.each_comment_in_lines(node.source_range.line_span)
 
           comments.each_with_object({}) do |comment, hash|
             merge_adjacent_comments(comment.text, comment.loc.line, hash)

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

@@ -10,7 +10,7 @@ module RuboCop
       # declarations.
       #
       # The documentation requirement is annulled if the class or module has
-      # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
+      # a `#:nodoc:` comment next to it. Likewise, `#:nodoc: all` does the
       # same for all its children.
       #
       # @example
@@ -110,7 +110,7 @@ module RuboCop
           return if nodoc_self_or_outer_module?(node)
           return if include_statement_only?(body)
 
-          range = range_between(node.loc.expression.begin_pos, node.loc.name.end_pos)
+          range = range_between(node.source_range.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
           add_offense(range, message: message)
         end
@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def compact_namespace?(node)
-          /::/.match?(node.loc.name.source)
+          node.loc.name.source.include?('::')
         end
 
         # First checks if the :nodoc: comment is associated with the
@@ -178,13 +178,19 @@ module RuboCop
         def identifier(node)
           # Get the fully qualified identifier for a class/module
           nodes = [node, *node.each_ancestor(:class, :module)]
-          nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+          identifier = nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+
+          identifier.sub('::::', '::')
         end
 
         def qualify_const(node)
-          return if node.nil? || node.cbase_type? || node.self_type? || node.send_type?
+          return if node.nil?
 
-          [qualify_const(node.namespace), node.short_name].compact
+          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+            node.source
+          else
+            [qualify_const(node.namespace), node.short_name].compact
+          end
         end
       end
     end

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

@@ -7,6 +7,10 @@ module RuboCop
       # It can optionally be configured to also require documentation for
       # non-public methods.
       #
+      # NOTE: This cop allows `initialize` method because `initialize` is
+      # a special method called from `new`. In some programming languages
+      # they are called constructor to distinguish it from method.
+      #
       # @example
       #
       #   # bad
@@ -97,14 +101,16 @@ module RuboCop
 
         MSG = 'Missing method documentation comment.'
 
-        # @!method module_function_node?(node)
-        def_node_matcher :module_function_node?, <<~PATTERN
-          (send nil? :module_function ...)
+        # @!method modifier_node?(node)
+        def_node_matcher :modifier_node?, <<~PATTERN
+          (send nil? {:module_function :ruby2_keywords} ...)
         PATTERN
 
         def on_def(node)
+          return if node.method?(:initialize)
+
           parent = node.parent
-          module_function_node?(parent) ? check(parent) : check(node)
+          modifier_node?(parent) ? check(parent) : check(node)
         end
         alias on_defs on_def
 

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

@@ -103,12 +103,12 @@ module RuboCop
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
           return parent if parent.def_type? || parent.defs_type?
-          return node.parent.child_nodes.first if define_mehod?(parent)
+          return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
-        def define_mehod?(node)
+        def define_method?(node)
           return false unless node.block_type?
 
           child = node.child_nodes.first

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
         end
       end
     end

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

@@ -37,7 +37,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           block = node.parent
-          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+          range = range_between(block.loc.begin.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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_lambda_parameter.rb

@@ -34,7 +34,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+          range = range_between(send_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         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
@@ -57,7 +57,7 @@ module RuboCop
         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`; ' \
@@ -146,7 +146,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.loc.expression, message: message) do |corrector|
+          add_offense(line_node.source_range, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end
@@ -175,14 +175,14 @@ module RuboCop
         end
 
         def line_difference(line_node, code)
-          string_first_line(code) - line_node.loc.expression.first_line
+          string_first_line(code) - line_node.source_range.first_line
         end
 
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
           else
-            str_node.loc.expression.first_line
+            str_node.source_range.first_line
           end
         end
 
@@ -210,7 +210,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.loc.expression.end, ", #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
           end
         end
 

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

@@ -0,0 +1,68 @@
+# 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
+          (send
+            _ {:=~ :=== :!~ :match :match?}
+            (regexp
+              (str $_)
+              (regopt)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp = exact_regexp_match(node))
+
+          parsed_regexp = Regexp::Parser.parse(regexp)
+          return unless exact_match_pattern?(parsed_regexp)
+
+          prefer = "#{node.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
+
+        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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
+          range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `File.empty?('path/to/file')` when checking if a file is empty.
+      #
+      # @safety
+      #   This cop is unsafe, because `File.size`, `File.read`, and `File.binread`
+      #   raise `ENOENT` exception when there is no file corresponding to the path,
+      #   while `File.empty?` does not raise an exception.
+      #
+      # @example
+      #   # bad
+      #   File.zero?('path/to/file')
+      #   File.size('path/to/file') == 0
+      #   File.size('path/to/file') >= 0
+      #   File.size('path/to/file').zero?
+      #   File.read('path/to/file').empty?
+      #   File.binread('path/to/file') == ''
+      #   FileTest.zero?('path/to/file')
+      #
+      #   # good
+      #   File.empty?('path/to/file')
+      #   FileTest.empty?('path/to/file')
+      #
+      class FileEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<file_class>s.empty?(%<arg>s)` instead.'
+        RESTRICT_ON_SEND = %i[>= != == zero? empty?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send $(const {nil? cbase} {:File :FileTest}) :zero? $_)
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) {:== :>=} (int 0))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :!) {:== :>=} (int 0))
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :zero?)
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) {:!= :==} (str empty?))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :!) {:!= :==} (str empty?))
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :empty?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            add_offense(node,
+                        message: format(MSG, file_class: const_node.source,
+                                             arg: arg_node.source)) do |corrector|
+              corrector.replace(node,
+                                "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})")
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          if (node.method?(:==) && node.child_nodes.first.method?(:!)) ||
+             (%i[>= !=].include?(node.method_name) && !node.child_nodes.first.method?(:!))
+            '!'
+          end
+        end
+      end
+    end
+  end
+end