rubocop 0.93.1 → 1.79.2

data/lib/rubocop/cop/mixin/documentation_comment.rb

@@ -5,7 +5,6 @@ module RuboCop
     # Common functionality for checking documentation.
     module DocumentationComment
       extend NodePattern::Macros
-      include Style::AnnotationComment
 
       private
 
@@ -15,7 +14,7 @@ module RuboCop
         return false unless preceding_comment?(node, preceding_lines.last)
 
         preceding_lines.any? do |comment|
-          !annotation?(comment) &&
+          !AnnotationComment.new(comment, annotation_keywords).annotation? &&
             !interpreter_directive_comment?(comment) &&
             !rubocop_directive_comment?(comment)
         end
@@ -24,8 +23,7 @@ module RuboCop
       # The args node1 & node2 may represent a RuboCop::AST::Node
       # or a Parser::Source::Comment. Both respond to #loc.
       def preceding_comment?(node1, node2)
-        node1 && node2 && precede?(node2, node1) &&
-          comment_line?(node2.loc.expression.source)
+        node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
       end
 
       # The args node1 & node2 may represent a RuboCop::AST::Node
@@ -35,9 +33,7 @@ module RuboCop
       end
 
       def preceding_lines(node)
-        processed_source.ast_with_comments[node].select do |line|
-          line.loc.line < node.loc.line
-        end
+        processed_source.ast_with_comments[node].select { |line| line.loc.line < node.loc.line }
       end
 
       def interpreter_directive_comment?(comment)
@@ -45,7 +41,11 @@ module RuboCop
       end
 
       def rubocop_directive_comment?(comment)
-        CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
+        !!DirectiveComment.new(comment).match_captures
+      end
+
+      def annotation_keywords
+        config.for_cop('Style/CommentAnnotation')['Keywords']
       end
     end
   end

data/lib/rubocop/cop/mixin/duplication.rb

@@ -29,7 +29,7 @@ module RuboCop
       # @param [Array] collection an array to return consecutive duplicates for
       # @return [Array] the consecutive duplicates
       def consecutive_duplicates(collection)
-        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+        grouped_duplicates(collection).flat_map { |items| items[1..] }
       end
 
       # Returns a hash of grouped duplicates. The key will be the first

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -10,17 +10,18 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG_EXTRA = 'Extra empty line detected at %<kind>s body ' \
-                    '%<location>s.'
+        MSG_EXTRA = 'Extra empty line detected at %<kind>s body %<location>s.'
         MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'
-        MSG_DEFERRED = 'Empty line missing before first %<type>s ' \
-                       'definition'
+        MSG_DEFERRED = 'Empty line missing before first %<type>s definition'
 
         private
 
+        # @!method constant_definition?(node)
         def_node_matcher :constant_definition?, '{class module}'
+
+        # @!method empty_line_required?(node)
         def_node_matcher :empty_line_required?,
-                         '{def defs class module (send nil? {:private :protected :public})}'
+                         '{any_def class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)
@@ -90,9 +91,7 @@ module RuboCop
           when :no_empty_lines
             check_line(style, line_no, message(MSG_EXTRA, desc), &:empty?)
           when :empty_lines
-            check_line(style, line_no, message(MSG_MISSING, desc)) do |line|
-              !line.empty?
-            end
+            check_line(style, line_no, message(MSG_MISSING, desc)) { |line| !line.empty? }
           end
         end
 

data/lib/rubocop/cop/mixin/empty_parameter.rb

@@ -8,6 +8,7 @@ module RuboCop
 
       private
 
+      # @!method empty_arguments?(node)
       def_node_matcher :empty_arguments?, <<~PATTERN
         (block _ $(args) _)
       PATTERN
@@ -16,9 +17,7 @@ module RuboCop
         empty_arguments?(node) do |args|
           return if args.empty_and_without_delimiters?
 
-          add_offense(args) do |corrector|
-            autocorrect(corrector, args)
-          end
+          add_offense(args) { |corrector| autocorrect(corrector, args) }
         end
       end
     end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -34,8 +34,7 @@ module RuboCop
 
       def matching_ranges(end_loc, align_ranges)
         align_ranges.select do |_, range|
-          range.line == end_loc.line ||
-            column_offset_between(range, end_loc).zero?
+          same_line?(range, end_loc) || column_offset_between(range, end_loc).zero?
         end
       end
 
@@ -55,9 +54,7 @@ module RuboCop
                           source: align_with.source,
                           align_line: align_with.line,
                           align_col: align_with.column)
-        add_offense(end_loc, message: msg) do |corrector|
-          autocorrect(corrector, node)
-        end
+        add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
       end
 
       def accept_end_kw_alignment?(end_loc)
@@ -70,7 +67,7 @@ module RuboCop
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        return if end_alignment_style == :keyword
+        return false if end_alignment_style == :keyword
 
         !line_break_before_keyword?(whole_expression, rhs)
       end

data/lib/rubocop/cop/mixin/endless_method_rewriter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for rewriting endless methods to normal method definitions
+    module EndlessMethodRewriter
+      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
+
+      private
+
+      def arguments(node, missing = '')
+        node.arguments.any? ? node.arguments.source : missing
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -2,13 +2,29 @@
 
 module RuboCop
   module Cop
-    # Common functionality for enforcing a specific superclass
+    # Common functionality for enforcing a specific superclass.
+    #
+    # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
+    # Rails department has been extracted to RuboCop Rails gem.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
+    # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
+    # with existing RuboCop Rails 2.8 or lower.
+    #
+    # @api private
     module EnforceSuperclass
       def self.included(base)
+        warn Rainbow(
+          '`RuboCop::Cop::EnforceSuperclass` is deprecated and will be removed in RuboCop 2.0. ' \
+          'Please upgrade to RuboCop Rails 2.9 or newer to continue.'
+        ).yellow
+
+        # @!method class_definition(node)
         base.def_node_matcher :class_definition, <<~PATTERN
           (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
         PATTERN
 
+        # @!method class_new_definition(node)
         base.def_node_matcher :class_new_definition, <<~PATTERN
           [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
            !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
@@ -17,15 +33,11 @@ module RuboCop
       end
 
       def on_class(node)
-        class_definition(node) do
-          add_offense(node.children[1])
-        end
+        class_definition(node) { add_offense(node.children[1]) }
       end
 
       def on_send(node)
-        class_new_definition(node) do
-          add_offense(node.children.last)
-        end
+        class_new_definition(node) { add_offense(node.children.last) }
       end
     end
   end

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -7,12 +7,12 @@ module RuboCop
     module FirstElementLineBreak
       private
 
-      def check_method_line_break(node, children)
+      def check_method_line_break(node, children, ignore_last: false)
         return if children.empty?
 
         return unless method_uses_parens?(node, children.first)
 
-        check_children_line_break(node, children)
+        check_children_line_break(node, children, ignore_last: ignore_last)
       end
 
       def method_uses_parens?(node, limit)
@@ -20,28 +20,30 @@ module RuboCop
         /\s*\(\s*$/.match?(source)
       end
 
-      def check_children_line_break(node, children, start = node)
-        return if children.size < 2
+      def check_children_line_break(node, children, start = node, ignore_last: false)
+        return if children.empty?
 
         line = start.first_line
 
         min = first_by_line(children)
         return if line != min.first_line
 
-        max = last_by_line(children)
-        return if line == max.last_line
+        max_line = last_line(children, ignore_last: ignore_last)
+        return if line == max_line
 
-        add_offense(min) do |corrector|
-          EmptyLineCorrector.insert_before(corrector, min)
-        end
+        add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
       end
 
       def first_by_line(nodes)
         nodes.min_by(&:first_line)
       end
 
-      def last_by_line(nodes)
-        nodes.max_by(&:last_line)
+      def last_line(nodes, ignore_last:)
+        if ignore_last
+          nodes.map(&:first_line)
+        else
+          nodes.map(&:last_line)
+        end.max
       end
     end
   end

data/lib/rubocop/cop/mixin/forbidden_identifiers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain identifiers in a cop.
+    module ForbiddenIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def forbidden_identifier?(name)
+        name = name.to_s.delete(SIGILS)
+
+        forbidden_identifiers.any? && forbidden_identifiers.include?(name)
+      end
+
+      def forbidden_identifiers
+        cop_config.fetch('ForbiddenIdentifiers', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/forbidden_pattern.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain patterns in a cop.
+    module ForbiddenPattern
+      def forbidden_pattern?(name)
+        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+      end
+
+      def forbidden_patterns
+        cop_config.fetch('ForbiddenPatterns', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -6,36 +6,71 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL = '# frozen_string_literal:'
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
-      FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
+      FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
+
+      private_constant :FROZEN_STRING_LITERAL_TYPES_RUBY27
 
       def frozen_string_literal_comment_exists?
-        leading_comment_lines.any? do |line|
-          MagicComment.parse(line).valid_literal_value?
-        end
+        leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
       end
 
       private
 
+      def frozen_string_literal?(node)
+        frozen_string = if target_ruby_version >= 3.0
+                          uninterpolated_string?(node) || uninterpolated_heredoc?(node)
+                        else
+                          FROZEN_STRING_LITERAL_TYPES_RUBY27.include?(node.type)
+                        end
+
+        frozen_string && frozen_string_literals_enabled?
+      end
+
+      def uninterpolated_string?(node)
+        node.str_type? || (
+          node.dstr_type? && node.each_descendant(:begin, :ivar, :cvar, :gvar).none?
+        )
+      end
+
+      def uninterpolated_heredoc?(node)
+        return false unless node.dstr_type? && node.heredoc?
+
+        node.children.all?(&:str_type?)
+      end
+      alias frozen_heredoc? uninterpolated_heredoc?
+
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
 
+        # Check if a magic string literal comment specifies what to do
+        magic_comments = leading_comment_lines.filter_map { |line| MagicComment.parse(line) }
+        if (literal_magic_comment = magic_comments.find(&:frozen_string_literal_specified?))
+          return literal_magic_comment.frozen_string_literal?
+        end
+
         # TODO: Ruby officially abandon making frozen string literals default
         # for Ruby 3.0.
         # https://bugs.ruby-lang.org/issues/11473#note-53
-        # Whether frozen string literals will be the default after Ruby 3.0
-        # or not is still unclear as of January 2019.
+        # Whether frozen string literals will be the default after Ruby 4.0
+        # or not is still unclear as of July 2024.
         # It may be necessary to add this code in the future.
         #
-        #   return true if ruby_version >= 3.1
+        #   return ruby_version >= 4.0 if string_literals_frozen_by_default?.nil?
         #
-        # And the above `ruby_version >= 3.1` is undecided whether it will be
-        # Ruby 3.1, 3.2, 4.0 or others.
-        # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
+        # And the above `ruby_version >= 4.0` is undecided whether it will be
+        # Ruby 4.0 or others.
+        # See https://bugs.ruby-lang.org/issues/20205 for details.
+        # For now, offer a configuration value to override behavior is using RUBYOPT.
+        return false if string_literals_frozen_by_default?.nil?
+
+        string_literals_frozen_by_default?
+      end
+
+      def frozen_string_literals_disabled?
         leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal?
+          MagicComment.parse(line).frozen_string_literal == false
         end
       end
 
@@ -45,14 +80,16 @@ module RuboCop
         end
       end
 
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
       def leading_comment_lines
-        first_non_comment_token = processed_source.tokens.find do |token|
-          !token.comment?
-        end
+        first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
 
         if first_non_comment_token
           # `line` is 1-indexed so we need to subtract 1 to get the array index
-          processed_source.lines[0...first_non_comment_token.line - 1]
+          processed_source.lines[0...(first_non_comment_token.line - 1)]
         else
           processed_source.lines
         end

data/lib/rubocop/cop/mixin/gem_declaration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemDeclaration
+      extend NodePattern::Macros
+
+      # @!method gem_declaration?(node)
+      def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
+    end
+  end
+end

data/lib/rubocop/cop/mixin/gemspec_help.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemspecHelp
+      extend NodePattern::Macros
+
+      # @!method gem_specification?(node)
+      def_node_matcher :gem_specification?, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+
+      # @!method gem_specification(node)
+      def_node_search :gem_specification, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+
+      # @!method assignment_method_declarations(node)
+      def_node_search :assignment_method_declarations, <<~PATTERN
+        (send
+          (lvar {#match_block_variable_name? :_1 :it}) _ ...)
+      PATTERN
+
+      # @!method indexed_assignment_method_declarations(node)
+      def_node_search :indexed_assignment_method_declarations, <<~PATTERN
+        (send
+          (send (lvar {#match_block_variable_name? :_1 :it}) _)
+          :[]=
+          literal?
+          _
+        )
+      PATTERN
+
+      def match_block_variable_name?(receiver_name)
+        gem_specification(processed_source.ast) do |block_variable_name|
+          return block_variable_name == receiver_name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(first_pair, _node)
+        def deltas_for_first_pair(first_pair)
           {
             separator: separator_delta(first_pair),
             value: value_delta(first_pair)
@@ -33,7 +33,7 @@ module RuboCop
 
         def separator_delta(pair)
           if pair.hash_rocket?
-            correct_separator_column = pair.key.loc.expression.end.column + 1
+            correct_separator_column = pair.key.source_range.end.column + 1
             actual_separator_column = pair.loc.operator.column
 
             correct_separator_column - actual_separator_column
@@ -43,7 +43,7 @@ module RuboCop
         end
 
         def value_delta(pair)
-          return 0 if pair.kwsplat_type? || pair.value_on_new_line?
+          return 0 if pair.value_on_new_line? || pair.value_omission?
 
           correct_value_column = pair.loc.operator.end.column + 1
           actual_value_column = pair.value.loc.column
@@ -60,10 +60,8 @@ module RuboCop
 
         def deltas(first_pair, current_pair)
           key_delta = key_delta(first_pair, current_pair)
-          separator_delta = separator_delta(first_pair, current_pair,
-                                            key_delta)
-          value_delta = value_delta(first_pair, current_pair) -
-                        key_delta - separator_delta
+          separator_delta = separator_delta(first_pair, current_pair, key_delta)
+          value_delta = value_delta(first_pair, current_pair) - key_delta - separator_delta
 
           { key: key_delta, separator: separator_delta, value: value_delta }
         end
@@ -83,13 +81,7 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        def initialize
-          self.max_key_width = 0
-        end
-
-        def deltas_for_first_pair(first_pair, node)
-          self.max_key_width = node.keys.map { |key| key.source.length }.max
-
+        def deltas_for_first_pair(first_pair)
           separator_delta = separator_delta(first_pair, first_pair, 0)
           {
             separator: separator_delta,
@@ -99,24 +91,29 @@ module RuboCop
 
         private
 
-        attr_accessor :max_key_width
-
         def key_delta(first_pair, current_pair)
           first_pair.key_delta(current_pair)
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 1 -
+          first_pair.loc.column + max_key_width(first_pair.parent) + 1 -
             current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
-          return 0 if current_pair.kwsplat_type?
-
           correct_value_column = first_pair.key.loc.column +
-                                 current_pair.delimiter(true).length +
-                                 max_key_width
-          correct_value_column - current_pair.value.loc.column
+                                 max_key_width(first_pair.parent) +
+                                 max_delimiter_width(first_pair.parent)
+
+          current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
+        end
+
+        def max_key_width(hash_node)
+          hash_node.keys.map { |key| key.source.length }.max
+        end
+
+        def max_delimiter_width(hash_node)
+          hash_node.pairs.map { |pair| pair.delimiter(true).length }.max
         end
       end
 
@@ -124,7 +121,7 @@ module RuboCop
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*_nodes)
+        def deltas_for_first_pair(_first_pair)
           {}
         end
 
@@ -139,7 +136,20 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          first_pair.value_delta(current_pair)
+          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
+        end
+      end
+
+      # Handles calculation of deltas for `kwsplat` nodes.
+      # This is a special case that just ensures the kwsplat is aligned with the rest of the hash
+      # since a `kwsplat` does not have a key, separator or value.
+      class KeywordSplatAlignment
+        def deltas(first_pair, current_pair)
+          if Util.begins_its_line?(current_pair.source_range)
+            { key: first_pair.key_delta(current_pair) }
+          else
+            {}
+          end
         end
       end
     end