rubocop 1.53.0 → 1.90.0

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

@@ -33,24 +33,20 @@ module RuboCop
           branch.begin_type? ? Array(branch).last : branch
         end
 
-        # rubocop:disable Metrics/AbcSize
         def lhs(node)
           case node.type
           when :send
             lhs_for_send(node)
-          when :op_asgn
-            "#{node.children[0].source} #{node.children[1]}= "
-          when :and_asgn, :or_asgn
-            "#{node.children[0].source} #{node.loc.operator.source} "
+          when :op_asgn, :and_asgn, :or_asgn
+            "#{node.assignment_node.source} #{node.operator}= "
           when :casgn
             lhs_for_casgn(node)
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
-            "#{node.children[0]} = "
+            "#{node.name} = "
           else
             node.source
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def indent(cop, source)
           conf = cop.config.for_cop(END_ALIGNMENT)
@@ -73,7 +69,7 @@ module RuboCop
           elsif_branches << node.if_branch
 
           else_branch = node.else_branch
-          if else_branch&.if_type? && else_branch&.elsif?
+          if else_branch&.if_type? && else_branch.elsif?
             expand_elsif(else_branch, elsif_branches)
           else
             elsif_branches << else_branch
@@ -94,29 +90,26 @@ module RuboCop
         end
 
         def lhs_for_casgn(node)
-          namespace = node.children[0]
-          if namespace.nil? || namespace.cbase_type?
-            "#{namespace&.source}#{node.children[1]} = "
+          if node.namespace.nil?
+            "#{node.name} = "
+          elsif node.namespace.cbase_type?
+            "::#{node.name} = "
           else
-            "#{namespace.source}::#{node.children[1]} = "
+            "#{node.namespace.const_name}::#{node.name} = "
           end
         end
 
-        def setter_method?(method_name)
-          method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
-        end
-
         def assignment_rhs_exist?(node)
           parent = node.parent
           return true unless parent
 
-          !(parent.mlhs_type? || parent.resbody_type?)
+          !parent.type?(:mlhs, :resbody)
         end
       end
 
-      # Check for `if` and `case` statements where each branch is used for
-      # assignment to the same variable when using the return of the
-      # condition can be used instead.
+      # Checks for `if` and `case` statements where each branch is used for
+      # both the assignment and comparison of the same variable
+      # when using the return of the condition can be used instead.
       #
       # @example EnforcedStyle: assign_to_condition (default)
       #   # bad
@@ -210,16 +203,14 @@ module RuboCop
       class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
-        include IgnoredNode
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
-        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals'
+        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals.'
         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'
         ENABLED = 'Enabled'
-        MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
@@ -233,7 +224,7 @@ module RuboCop
         PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
-          define_method "on_#{type}" do |node|
+          define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)
             return if node.parent&.shorthand_asgn?
 
@@ -293,8 +284,12 @@ module RuboCop
 
           _condition, *branches, else_branch = *assignment
 
-          return unless else_branch
+          # Use the node accessor rather than the raw destructured branch: for
+          # `x = unless cond; body; end` (no `else`) the parser puts `body` in the
+          # else slot, but `else_branch` correctly reports there is no `else` clause.
+          return unless assignment.else_branch
           return if allowed_single_line?([*branches, else_branch])
+          return unless safe_to_correct?(node)
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -313,22 +308,25 @@ module RuboCop
         end
 
         def allowed_single_line?(branches)
-          single_line_conditions_only? && branches.any?(&:begin_type?)
+          single_line_conditions_only? && branches.compact.any?(&:begin_type?)
         end
 
         def assignment_node(node)
-          *_variable, assignment = *node
+          assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
 
-          assignment, = *assignment if assignment.begin_type? && assignment.children.one?
+          if assignment.begin_type? && assignment.children.one?
+            assignment = assignment.children.first
+          end
 
           assignment
         end
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type? || node.case_match_type?
+          if node.type?(:case, :case_match)
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -338,11 +336,11 @@ module RuboCop
         end
 
         def move_assignment_inside_condition(corrector, node)
-          *_assignment, condition = *node
+          condition = node.send_type? ? node.last_argument : node.expression
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
-          elsif condition.case_type? || condition.case_match_type?
+          elsif condition.type?(:case, :case_match)
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)
@@ -371,6 +369,7 @@ module RuboCop
           return unless allowed_statements?(branches)
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
+          return unless safe_to_correct?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
@@ -383,6 +382,25 @@ module RuboCop
           end
         end
 
+        # The correction rewrites the conditional structurally, so full AST
+        # equivalence cannot be asserted, but the result must at least reparse
+        # to valid Ruby. Applying the correction to a throwaway buffer here
+        # also exercises the branch-shape handling before an offense is even
+        # reported, so unusual branches that the corrector cannot handle are
+        # left alone instead of crashing or emitting invalid code - the bug
+        # class behind most of this cop's history.
+        def safe_to_correct?(node)
+          correction_parses?(node)
+        rescue StandardError
+          false
+        end
+
+        # `ReparsedEquivalence#correction_parses?` contract: apply the exact
+        # correction this cop would perform.
+        def apply_reparse_correction(corrector, node)
+          autocorrect(corrector, node)
+        end
+
         def allowed_statements?(branches)
           return false unless branches.all?
 
@@ -400,7 +418,7 @@ module RuboCop
         # of the longest line + the length of the corrected assignment is
         # greater than the max configured line length
         def correction_exceeds_line_limit?(node, branches)
-          return false unless line_length_cop_enabled?
+          return false unless config.cop_enabled?('Layout/LineLength')
 
           assignment = lhs(tail(branches[0]))
 
@@ -418,14 +436,6 @@ module RuboCop
           assignment + longest_line
         end
 
-        def line_length_cop_enabled?
-          config.for_cop(LINE_LENGTH)[ENABLED]
-        end
-
-        def max_line_length
-          config.for_cop(LINE_LENGTH)[MAX]
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
@@ -438,31 +448,46 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
-            corrector.remove(white_space) if white_space.source.strip.empty?
+            corrector.remove(white_space) if white_space
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(
+            condition.branches.last.parent.else_branch, condition.loc.end
+          )
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
 
         def white_space_range(node, column)
           expression = node.source_range
-          begin_pos = expression.begin_pos - (expression.column - column - 2)
+          end_pos = expression.begin_pos
+          begin_pos = end_pos - (expression.column - column - 2)
+
+          return nil if begin_pos > end_pos
 
-          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
+          white_space = Parser::Source::Range.new(expression.source_buffer, begin_pos, end_pos)
+          white_space if white_space.source.strip.empty?
         end
 
         def assignment(node)
-          *_, condition = *node
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.source_range.begin_pos,
-                                    condition.source_range.begin_pos)
+          condition = node.send_type? ? node.last_argument : node.expression
+
+          node.source_range.begin.join(condition.source_range.begin)
         end
 
         def correct_if_branches(corrector, cop, node)
@@ -507,7 +532,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            *_var, rhs = *node
+            rhs = node.send_type? ? node.last_argument : node.expression
             if_branch, else_branch = extract_branches(node)
             assignment = assignment(node)
 
@@ -534,12 +559,12 @@ module RuboCop
           end
 
           def element_assignment?(node)
-            node.send_type? && node.method_name != :[]=
+            node.send_type? && !node.method?(:[]=)
           end
 
           def extract_branches(node)
-            *_var, rhs = *node
-            condition, = *rhs if rhs.begin_type? && rhs.children.one?
+            rhs = node.send_type? ? node.last_argument : node.expression
+            condition = rhs.children.first if rhs.begin_type? && rhs.children.one?
             _condition, if_branch, else_branch = *(condition || rhs)
 
             [if_branch, else_branch]
@@ -568,7 +593,7 @@ module RuboCop
 
           def move_assignment_inside_condition(corrector, node)
             column = node.source_range.column
-            *_var, condition = *node
+            condition = node.send_type? ? node.last_argument : node.expression
             assignment = assignment(node)
 
             corrector.remove(assignment)
@@ -596,6 +621,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end
@@ -619,7 +646,7 @@ module RuboCop
 
           def move_assignment_inside_condition(corrector, node)
             column = node.source_range.column
-            *_var, condition = *node
+            condition = node.send_type? ? node.last_argument : node.expression
             assignment = assignment(node)
 
             corrector.remove(assignment)
@@ -654,6 +681,8 @@ module RuboCop
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
+            return if same_line?(parent_keyword, condition)
+
             corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end

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

@@ -29,32 +29,36 @@ module RuboCop
       # @example IgnoreModules: false (default)
       #   # bad
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #   end
       #
       #   # good
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #     public_constant :MyClass
       #   end
       #
       # @example IgnoreModules: true
       #   # good
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #   end
       #
       class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
+        # @!method visibility_declaration_for(node)
+        def_node_matcher :visibility_declaration_for, <<~PATTERN
+          (send nil? {:public_constant :private_constant} $...)
+        PATTERN
+
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
           return if ignore_modules? && module?(node)
 
-          message = message(node)
-          add_offense(node, message: message)
+          add_offense(node, message: format(MSG, constant_name: node.name))
         end
 
         private
@@ -64,13 +68,7 @@ module RuboCop
         end
 
         def module?(node)
-          node.children.last.class_constructor?
-        end
-
-        def message(node)
-          _namespace, constant_name, _value = *node
-
-          format(MSG, constant_name: constant_name)
+          node.expression.class_constructor?
         end
 
         def class_or_module_scope?(node)
@@ -84,21 +82,21 @@ module RuboCop
           end
         end
 
+        # rubocop:disable-next Metrics/AbcSize
         def visibility_declaration?(node)
-          _namespace, constant_name, _value = *node
-
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, constant_name)
-          end
-        end
+            next false unless (arguments = visibility_declaration_for(child))
 
-        # @!method visibility_declaration_for?(node, const_name)
-        def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
-        PATTERN
+            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            constant_values = arguments.map do |argument|
+              # `respond_to?(:value)` is too broad: `int`/`float` nodes respond to it
+              # but their value is a `Numeric`, which has no `to_sym` (e.g.
+              # `private_constant 42`). Only symbol/string arguments are real names.
+              argument.value.to_sym if argument.type?(:sym, :str)
+            end
 
-        def match_name?(name, constant_name)
-          name.to_sym == constant_name.to_sym
+            constant_values.include?(node.name)
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check that a copyright notice was given in each source file.
+      # Checks that a copyright notice was given in each source file.
       #
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml. The default can be changed as follows:
@@ -25,40 +25,52 @@ module RuboCop
         MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
 
+        # rubocop:disable-next Metrics/AbcSize
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
 
-          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
-            verify_autocorrect_notice!
+          message = format(MSG, notice: notice)
+          if processed_source.blank?
+            add_global_offense(message)
+          else
+            offense_range = source_range(processed_source.buffer, 1, 0)
+            add_offense(offense_range, message: message) do |corrector|
+              next unless autocorrect?
 
-            token = insert_notice_before(processed_source)
-            range = token.nil? ? range_between(0, 0) : token.pos
+              verify_autocorrect_notice!
 
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
+              autocorrect(corrector)
+            end
           end
         end
 
         private
 
-        def notice
-          cop_config['Notice']
-        end
+        def autocorrect(corrector)
+          token = insert_notice_before(processed_source)
+          range = token.nil? ? range_between(0, 0) : token.pos
 
-        def autocorrect_notice
-          cop_config['AutocorrectNotice']
+          corrector.insert_before(range, "#{normalized_autocorrect_notice}\n")
         end
 
-        def offense_range
-          source_range(processed_source.buffer, 1, 0)
+        def normalized_autocorrect_notice
+          autocorrect_notice.lines.map do |line|
+            next line if line.start_with?('#')
+            next "#\n" if line.chomp.empty?
+
+            "# #{line}"
+          end.join
         end
 
         def verify_autocorrect_notice!
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          if autocorrect_notice.nil? || autocorrect_notice.empty?
+            raise Warning, "#{cop_name}: #{AUTOCORRECT_EMPTY_WARNING}"
+          end
 
-          regex = Regexp.new(notice)
-          return if autocorrect_notice&.match?(regex)
+          return if normalized_autocorrect_notice.gsub(/^# */, '').match?(notice_regexp)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          message = "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          raise Warning, "#{cop_name}: #{message}"
         end
 
         def insert_notice_before(processed_source)
@@ -72,26 +84,39 @@ module RuboCop
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && /^#!.*$/.match?(token.text)
+          token.comment? && /\A#!.*\z/.match?(token.text)
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
+          token.comment? && /\A#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
         end
 
         def notice_found?(processed_source)
-          notice_found = false
-          notice_regexp = Regexp.new(notice)
+          multiline_notice = +''
           processed_source.tokens.each do |token|
             break unless token.comment?
 
-            notice_found = notice_regexp.match?(token.text)
-            break if notice_found
+            multiline_notice << token.text.sub(/\A# */, '') << "\n"
+
+            break if notice_regexp.match?(token.text)
           end
-          notice_found
+
+          multiline_notice.match?(notice_regexp)
+        end
+
+        def notice_regexp
+          @notice_regexp ||= Regexp.new(notice.sub(/\A(?:\\A|\^)?#(?:\\s[*+?]?|\s)*/, ''))
+        end
+
+        def notice
+          cop_config['Notice']
+        end
+
+        def autocorrect_notice
+          cop_config['AutocorrectNotice']
         end
       end
     end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector
@@ -36,7 +43,7 @@ module RuboCop
         def on_class(node)
           return unless data_define?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
+          add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 
@@ -54,6 +61,10 @@ module RuboCop
 
         def correct_parent(parent, corrector)
           if parent.block_type?
+            # Convert a brace block to `do`, so the class's own `end` closes it
+            # once the closing delimiter is removed; otherwise a dangling `{` is
+            # left behind, producing invalid Ruby.
+            corrector.replace(parent.loc.begin, 'do') if parent.braces?
             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))

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for consistent usage of the `DateTime` class over the
-      # `Time` class. This cop is disabled by default since these classes,
+      # Checks for consistent usage of the `Time` class over the
+      # `DateTime` class. This cop is disabled by default since these classes,
       # although highly overlapping, have particularities that make them not
       # replaceable in certain situations when dealing with multiple timezones
       # and/or DST.
@@ -49,22 +49,22 @@ module RuboCop
       class DateTime < Base
         extend AutoCorrector
 
-        CLASS_MSG = 'Prefer Time over DateTime.'
-        COERCION_MSG = 'Do not use #to_datetime.'
+        CLASS_MSG = 'Prefer `Time` over `DateTime`.'
+        COERCION_MSG = 'Do not use `#to_datetime`.'
 
         # @!method date_time?(node)
         def_node_matcher :date_time?, <<~PATTERN
-          (send (const {nil? (cbase)} :DateTime) ...)
+          (call (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
         # @!method historic_date?(node)
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+          (call _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
-          (send _ :to_datetime)
+          (call !nil? :to_datetime)
         PATTERN
 
         def on_send(node)
@@ -75,6 +75,7 @@ module RuboCop
 
           add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
+        alias on_csend on_send
 
         private