rubocop 0.82.0 → 1.18.4

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

@@ -4,10 +4,18 @@ module RuboCop
   module Cop
     # Common functionality for checking length of code segments.
     module CodeLength
-      include ConfigurableMax
+      extend ExcludeLimit
+
+      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'
+
+      exclude_limit 'Max'
 
       private
 
+      def message(length, max_length)
+        format(MSG, label: cop_label, length: length, max: max_length)
+      end
+
       def max_length
         cop_config['Max']
       end
@@ -16,23 +24,36 @@ module RuboCop
         cop_config['CountComments']
       end
 
+      def count_as_one
+        Array(cop_config['CountAsOne']).map(&:to_sym)
+      end
+
       def check_code_length(node)
-        length = code_length(node)
+        # Skip costly calculation when definitely not needed
+        return if node.line_count <= max_length
 
-        return unless length > max_length
+        calculator = build_code_length_calculator(node)
+        length = calculator.calculate
+        return if length <= max_length
 
-        location = node.casgn_type? ? :name : :expression
+        location = node.casgn_type? ? node.loc.name : node.loc.expression
 
-        add_offense(node, location: location,
-                          message: message(length, max_length)) do
-          self.max = length
-        end
+        add_offense(location, message: message(length, max_length)) { self.max = length }
       end
 
       # Returns true for lines that shall not be included in the count.
       def irrelevant_line(source_line)
         source_line.blank? || !count_comments? && comment_line?(source_line)
       end
+
+      def build_code_length_calculator(node)
+        Metrics::Utils::CodeLengthCalculator.new(
+          node,
+          processed_source,
+          count_comments: count_comments?,
+          foldable_types: count_as_one
+        )
+      end
     end
   end
 end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for working with nodes containing comments.
+    module CommentsHelp
+      include VisibilityHelp
+
+      def source_range_with_comment(node)
+        begin_pos = begin_pos_with_comment(node)
+        end_pos = end_position_for(node)
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      private
+
+      def end_position_for(node)
+        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        buffer.line_range(end_line).end_pos
+      end
+
+      def begin_pos_with_comment(node)
+        first_comment = processed_source.ast_with_comments[node].first
+
+        if first_comment && (first_comment.loc.line < node.loc.line)
+          start_line_position(first_comment)
+        else
+          start_line_position(node)
+        end
+      end
+
+      def start_line_position(node)
+        buffer.line_range(node.loc.line).begin_pos - 1
+      end
+
+      def buffer
+        processed_source.buffer
+      end
+    end
+  end
+end

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

@@ -67,9 +67,7 @@ module RuboCop
       def style
         @style ||= begin
           s = cop_config[style_parameter_name].to_sym
-          unless supported_styles.include?(s)
-            raise "Unknown style #{s} selected!"
-          end
+          raise "Unknown style #{s} selected!" unless supported_styles.include?(s)
 
           s
         end
@@ -77,9 +75,9 @@ module RuboCop
 
       def alternative_style
         if supported_styles.size != 2
-          raise 'alternative_style can only be used when there are exactly ' \
-               '2 SupportedStyles'
+          raise 'alternative_style can only be used when there are exactly 2 SupportedStyles'
         end
+
         alternative_styles.first
       end
 

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

@@ -10,23 +10,18 @@ module RuboCop
         if valid_name?(node, name)
           correct_style_detected
         else
-          add_offense(node, location: name_range, message: message(style)) do
-            report_opposing_styles(node, name)
-          end
+          add_offense(name_range, message: message(style)) { report_opposing_styles(node, name) }
         end
       end
 
       def report_opposing_styles(node, name)
         alternative_styles.each do |alternative|
-          if valid_name?(node, name, alternative)
-            return unexpected_style_detected(alternative)
-          end
+          return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
       end
 
       def valid_name?(node, name, given_style = style)
-        name.match(self.class::FORMATS.fetch(given_style)) ||
-          class_emitter_method?(node, name)
+        name.match?(self.class::FORMATS.fetch(given_style)) || class_emitter_method?(node, name)
       end
 
       # A class emitter method is a singleton method in a class/module, where
@@ -38,9 +33,7 @@ module RuboCop
         # `def self.extended`, etc.
         node = node.parent while node.parent.defs_type?
 
-        node.parent.each_child_node(:class).any? do |c|
-          c.loc.name.is?(name.to_s)
-        end
+        node.parent.each_child_node(:class).any? { |c| c.loc.name.is?(name.to_s) }
       end
     end
   end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
+    # @deprecated Use `exclude_limit ParameterName` instead.
     module ConfigurableMax
       private
 

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

@@ -8,8 +8,8 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+        snake_case: /^@{0,2}[\d[[:lower:]]_]+[!?=]?$/,
+        camelCase:  /^@{0,2}(?:_|_?[[[:lower:]]][\d[[:lower:]][[:upper:]]]*)[!?=]?$/
       }.freeze
     end
   end

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

@@ -7,10 +7,11 @@ module RuboCop
     module ConfigurableNumbering
       include ConfigurableFormatting
 
+      implicit_param = /\A_\d+\z/
       FORMATS = {
-        snake_case:  /(?:[a-z_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
-        non_integer: /[A-Za-z_]$/
+        snake_case:  /(?:\D|_\d+|\A\d+)\z/,
+        normalcase:  /(?:\D|[^_\d]\d+|\A\d+)\z|#{implicit_param}/,
+        non_integer: /(\D|\A\d+)\z|#{implicit_param}/
       }.freeze
     end
   end

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

@@ -11,20 +11,18 @@ module RuboCop
       private
 
       def non_public?(node)
-        non_public_modifier?(node.parent) ||
-          preceding_non_public_modifier?(node)
+        non_public_modifier?(node.parent) || preceding_non_public_modifier?(node)
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.first_line).any? do |line|
-          NON_PUBLIC_MODIFIERS.include?(line)
-        end
+        stripped_source_upto(node.first_line).any? { |line| NON_PUBLIC_MODIFIERS.include?(line) }
       end
 
       def stripped_source_upto(index)
         processed_source[0..index].map(&:strip)
       end
 
+      # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
         (send nil? {:private :protected} ({def defs} ...))
       PATTERN

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

@@ -24,8 +24,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.loc.expression.source)
       end
 
       # The args node1 & node2 may represent a RuboCop::AST::Node
@@ -35,17 +34,15 @@ 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)
-        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+        /^#\s*(frozen_string_literal|encoding):/.match?(comment.text)
       end
 
       def rubocop_directive_comment?(comment)
-        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+        !!DirectiveComment.new(comment).match_captures
       end
     end
   end

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

@@ -10,16 +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}'
-        def_node_matcher :empty_line_required?, '{def defs class module}'
+
+        # @!method empty_line_required?(node)
+        def_node_matcher :empty_line_required?,
+                         '{def defs class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)
@@ -89,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
 
@@ -100,7 +100,9 @@ module RuboCop
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
           range = source_range(processed_source.buffer, line + offset, 0)
-          add_offense([style, range], location: range, message: msg)
+          add_offense(range, message: msg) do |corrector|
+            EmptyLineCorrector.correct(corrector, [style, range])
+          end
         end
 
         def check_deferred_empty_line(body)
@@ -112,11 +114,9 @@ module RuboCop
 
           range = source_range(processed_source.buffer, line + 2, 0)
 
-          add_offense(
-            [:empty_lines, range],
-            location: range,
-            message: deferred_message(node)
-          )
+          add_offense(range, message: deferred_message(node)) do |corrector|
+            EmptyLineCorrector.correct(corrector, [:empty_lines, range])
+          end
         end
 
         def namespace?(body, with_one_child: false)

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,7 +17,7 @@ module RuboCop
         empty_arguments?(node) do |args|
           return if args.empty_and_without_delimiters?
 
-          add_offense(args)
+          add_offense(args) { |corrector| autocorrect(corrector, args) }
         end
       end
     end

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

@@ -39,6 +39,15 @@ module RuboCop
         end
       end
 
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
+
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
+      end
+
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
         msg = format(MSG, end_line: end_loc.line,
@@ -46,12 +55,12 @@ module RuboCop
                           source: align_with.source,
                           align_line: align_with.line,
                           align_col: align_with.column)
-        add_offense(node, location: end_loc, message: msg)
+        add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
       end
 
       def accept_end_kw_alignment?(end_loc)
         end_loc.nil? || # Discard modifier forms of if/while/until.
-          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
       end
 
       def style_parameter_name

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

@@ -2,28 +2,36 @@
 
 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.
+    # 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)
+        # @!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? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       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

@@ -17,11 +17,11 @@ module RuboCop
 
       def method_uses_parens?(node, limit)
         source = node.source_range.source_line[0...limit.loc.column]
-        source =~ /\s*\(\s*$/
+        /\s*\(\s*$/.match?(source)
       end
 
       def check_children_line_break(node, children, start = node)
-        return if children.size < 2
+        return if children.empty?
 
         line = start.first_line
 
@@ -31,7 +31,7 @@ module RuboCop
         max = last_by_line(children)
         return if line == max.last_line
 
-        add_offense(min)
+        add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
       end
 
       def first_by_line(nodes)

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

@@ -11,9 +11,7 @@ module RuboCop
       FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
 
       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
@@ -34,8 +32,12 @@ module RuboCop
         # 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.
+        leading_comment_lines.any? { |line| MagicComment.parse(line).frozen_string_literal? }
+      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
 
@@ -46,7 +48,14 @@ module RuboCop
       end
 
       def leading_comment_lines
-        processed_source.comments.first(3).map(&:text)
+        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]
+        else
+          processed_source.lines
+        end
       end
     end
   end