rubocop 1.90.0 → 1.92.0

data/lib/rubocop/cop/lint/misplaced_magic_comment.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for magic comments placed where Ruby silently ignores them.
+      #
+      # The `encoding` magic comment is only honored on the first line of a file,
+      # or on the second line when the first line is a shebang. Anywhere else it
+      # is silently ignored - even directly below another comment or a blank line.
+      #
+      # Other magic comments (such as `frozen_string_literal`) are honored
+      # anywhere before the first token of code, but are ignored after any code,
+      # with a warning emitted only when running Ruby with `-w`.
+      #
+      # A magic comment misplaced ahead of a shebang also renders the shebang
+      # ineffective, since a shebang is only recognized on the first line.
+      #
+      # NOTE: An `encoding` comment that is only preceded by other magic
+      # comments is not flagged by this cop; that case is handled by
+      # `Lint/OrderedMagicComments`. `shareable_constant_value` is never
+      # flagged, as Ruby intentionally allows it mid-file with block scoping.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because moving the magic comment
+      #   to its effective position activates it, which changes runtime
+      #   behavior (e.g. the source encoding or string mutability).
+      #
+      # @example
+      #   # bad
+      #   # Documentation comment
+      #   # encoding: ascii-8bit
+      #   puts 'hello'
+      #
+      #   # good
+      #   # encoding: ascii-8bit
+      #   # Documentation comment
+      #   puts 'hello'
+      #
+      #   # bad
+      #   require 'foo'
+      #   # frozen_string_literal: true
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #   require 'foo'
+      #
+      #   # bad
+      #   # frozen_string_literal: true
+      #   #!/usr/bin/env ruby
+      #   puts 'hello'
+      #
+      #   # good
+      #   #!/usr/bin/env ruby
+      #   # frozen_string_literal: true
+      #   puts 'hello'
+      class MisplacedMagicComment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_ENCODING = 'The `encoding` magic comment is ignored unless placed on the first ' \
+                       'line (or below a shebang on the first line).'
+        MSG_AFTER_CODE = 'The `%<directive>s` magic comment is ignored after any code.'
+        MSG_ABOVE_SHEBANG = 'A magic comment above a shebang renders the shebang ineffective.'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          check_magic_comment_above_shebang
+          processed_source.comments.each { |comment| check_comment(comment) }
+        end
+
+        private
+
+        def check_comment(comment)
+          return unless magic_comment_shaped?(comment.text)
+
+          magic_comment = MagicComment.parse(comment.text)
+          return unless magic_comment.valid?
+
+          if magic_comment.encoding_specified?
+            return unless known_encoding?(magic_comment.encoding)
+
+            check_encoding_comment(comment)
+          elsif magic_comment.frozen_string_literal_specified?
+            check_top_block_comment(comment, 'frozen_string_literal')
+          end
+        end
+
+        # The Emacs and Vim regexps in `MagicComment` match anywhere inside a
+        # comment, which would flag documentation that merely quotes a magic
+        # comment (e.g. `#   # -*- coding: UTF-8 -*-`). Require the magic
+        # comment to start right after the `#`.
+        def magic_comment_shaped?(text)
+          /\A#(?![^#]*#)/.match?(text)
+        end
+
+        # Prose that happens to open with `Encoding:` parses as an encoding
+        # comment (`# Encoding: force given encoding` yields `force`). Ruby
+        # ignores a misplaced encoding comment entirely, so a name no encoding
+        # answers to means the line is a comment, not a directive.
+        def known_encoding?(name)
+          Encoding.find(name)
+          true
+        rescue ArgumentError
+          false
+        end
+
+        def shebang?
+          processed_source.lines.first.to_s.start_with?('#!')
+        end
+
+        # First line that may carry an effective encoding comment.
+        def effective_encoding_line
+          shebang? ? 2 : 1
+        end
+
+        def first_code_token
+          processed_source.sorted_tokens.find { |token| !token.comment? }
+        end
+
+        def check_encoding_comment(comment)
+          return unless misplaced_encoding_position?(comment)
+
+          add_offense(comment, message: MSG_ENCODING) do |corrector|
+            correct_encoding_comment(corrector, comment)
+          end
+        end
+
+        def misplaced_encoding_position?(comment)
+          line = comment.source_range.line
+          return false if line == effective_encoding_line && comment_starts_line?(comment)
+
+          # Leave `# frozen_string_literal: true` + `# encoding: x` runs at the
+          # very top to Lint/OrderedMagicComments, which already reorders them.
+          !preceded_only_by_magic_comments?(comment)
+        end
+
+        # With an effective encoding comment already in place, moving another
+        # one in would override it. Drop an identical duplicate and leave a
+        # conflicting one for a human to resolve.
+        def correct_encoding_comment(corrector, comment)
+          effective_comment = effective_encoding_comment
+
+          if effective_comment.nil?
+            move_comment(corrector, comment, effective_encoding_line)
+          elsif comment_encoding(effective_comment) == comment_encoding(comment)
+            corrector.remove(comment_removal_range(comment))
+          end
+        end
+
+        def comment_encoding(comment)
+          Encoding.find(MagicComment.parse(comment.text).encoding)
+        rescue ArgumentError
+          nil
+        end
+
+        def check_top_block_comment(comment, directive)
+          return unless first_code_token
+          return unless comment.source_range.begin_pos > first_code_token.begin_pos
+
+          message = format(MSG_AFTER_CODE, directive: directive)
+          add_offense(comment, message: message) do |corrector|
+            # Both would be inserted at the top, in no reliable order. Leave
+            # this one to the next pass, once the encoding comment is in place.
+            next if encoding_comment_moving_in?
+
+            move_comment(corrector, comment, top_block_insertion_line)
+          end
+        end
+
+        def encoding_comment_moving_in?
+          return false if effective_encoding_comment
+
+          processed_source.comments.any? do |comment|
+            known_encoding_comment?(comment) && misplaced_encoding_position?(comment)
+          end
+        end
+
+        def effective_encoding_comment
+          processed_source.comments.find do |comment|
+            comment.source_range.line == effective_encoding_line &&
+              comment_starts_line?(comment) &&
+              MagicComment.parse(comment.text).encoding_specified?
+          end
+        end
+
+        def known_encoding_comment?(comment)
+          return false unless magic_comment_shaped?(comment.text)
+
+          magic_comment = MagicComment.parse(comment.text)
+          magic_comment.encoding_specified? && known_encoding?(magic_comment.encoding)
+        end
+
+        # Insert below an effective encoding comment rather than above it,
+        # which would push it off the only lines where Ruby honors it.
+        def top_block_insertion_line
+          effective_encoding_comment ? effective_encoding_line + 1 : effective_encoding_line
+        end
+
+        def check_magic_comment_above_shebang
+          shebang_comment = processed_source.comments.find do |comment|
+            comment.source_range.line > 1 && comment.text.start_with?('#!') &&
+              comment.source_range.column.zero?
+          end
+          return unless shebang_comment
+          # Only flag when what precedes the shebang is magic comments -
+          # a `#!` comment deep inside a file is not an intended shebang.
+          return unless preceded_only_by_magic_comments?(shebang_comment)
+
+          add_offense(shebang_comment, message: MSG_ABOVE_SHEBANG)
+        end
+
+        def preceded_only_by_magic_comments?(comment)
+          (1...comment.source_range.line).all? do |line_number|
+            text = processed_source.lines[line_number - 1]
+            (line_number == 1 && text.start_with?('#!')) || MagicComment.parse(text).valid?
+          end
+        end
+
+        def comment_starts_line?(comment)
+          processed_source.lines[comment.source_range.line - 1].lstrip.start_with?('#')
+        end
+
+        def move_comment(corrector, comment, target_line)
+          corrector.remove(comment_removal_range(comment))
+          target_range = processed_source.buffer.line_range(target_line)
+          if comment.source_range.line < target_line
+            corrector.insert_after(target_range, "\n#{comment.text}")
+          else
+            corrector.insert_before(target_range, "#{comment.text}\n")
+          end
+        end
+
+        def comment_removal_range(comment)
+          if comment_starts_line?(comment)
+            range_by_whole_lines(comment.source_range, include_final_newline: true)
+          else
+            range_with_surrounding_space(comment.source_range, side: :left)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/missing_cop_enable_directive.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable-next Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint
@@ -62,7 +62,7 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            comment = processed_source.comment_at_line(line_range.begin)
+            comment = opening_comment(line_range)
 
             add_offense(comment, message: message(cop, comment))
           end
@@ -73,14 +73,29 @@ module RuboCop
         def each_missing_enable
           processed_source.disabled_line_ranges.each do |cop, line_ranges|
             line_ranges.each do |line_range|
-              # A `disable-next` scope closes itself with its statement.
-              next if line_range.respond_to?(:directive) && line_range.directive.disable_next?
+              # A `disable-next` or `next` scope closes itself with its statement.
+              next if statement_scoped?(line_range)
 
               yield cop, line_range
             end
           end
         end
 
+        def statement_scoped?(line_range)
+          directive = line_range.respond_to?(:directive) && line_range.directive
+          directive && (directive.disable_next? || directive.next?)
+        end
+
+        # A disable suspended by `enable-next` or `next +Cop` reopens below the
+        # statement, on a code line, so the comment that opened it has to come
+        # from the range rather than from its first line.
+        def opening_comment(line_range)
+          directive = line_range.respond_to?(:directive) && line_range.directive
+          return directive.comment if directive
+
+          processed_source.comment_at_line(line_range.begin)
+        end
+
         def acceptable_range?(cop, line_range)
           # This has to remain a strict inequality to handle
           # the case when max_range is Float::INFINITY

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -95,7 +95,7 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring -- the first child differs between `def` and `defs`
           return if node.defs_type? && allowed_subject_type?(subject)
 
           def_ancestor = node.each_ancestor(:any_def).first

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -67,7 +67,7 @@ module RuboCop
 
         # NOTE: itblock is not handled because this cop is limited to Ruby <= 2.7
         # via `maximum_target_ruby_version`, so itblock nodes (Ruby 3.4+) are never encountered.
-        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler -- limited to Ruby <= 2.7, where `it` blocks do not exist
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -132,7 +132,7 @@ module RuboCop
 
         def handle_as_symbol(node)
           to_method_symbol(node) do |receiver, sym_node, to_method|
-            next if receiver.nil? || !node.arguments.one?
+            next if receiver.nil? || !node.arguments.one? || node.operator_method?
 
             message = format(
               MSG,

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -46,13 +46,29 @@ module RuboCop
 
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
-            compound_range?(first_arg)
+            compound_range?(first_arg) || invalid_bare_argument?(first_arg)
         end
 
         def compound_range?(first_arg)
           first_arg.range_type? && first_arg.parenthesized_call?
         end
 
+        def invalid_bare_argument?(node)
+          node = node.children.first while node&.begin_type? && node.children.one?
+          return false unless node
+
+          keyword_operator?(node) || modifier_expression?(node)
+        end
+
+        def keyword_operator?(node)
+          (node.operator_keyword? && node.semantic_operator?) ||
+            node.rescue_type? || (node.send_type? && node.prefix_not?)
+        end
+
+        def modifier_expression?(node)
+          node.type?(:if, :while, :until) && node.modifier_form?
+        end
+
         def chained_calls?(node)
           first_argument = node.first_argument
           first_argument.call_type? && (node.children.last&.children&.count || 0) > 1

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -2,7 +2,7 @@
 
 # The Lint/RedundantCopDisableDirective cop needs to be disabled so as
 # to be able to provide a (bad) example of a redundant disable.
-# rubocop:disable-next Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint
@@ -110,7 +110,7 @@ module RuboCop
             # A pending cop that is not enabled in this run produces no
             # offenses, so its directives cannot be judged - they typically
             # prepare the code for the moment the cop gets enabled.
-            next if pending_cop_not_run?(cop)
+            next if pending_cop_not_run?(cop) || disabled_by_preview?(cop)
 
             each_already_disabled(cop, line_ranges, &block)
             each_line_range(cop, line_ranges, &block)
@@ -128,6 +128,17 @@ module RuboCop
             !processed_source.registry.enabled_pending_cop?(cop_cfg, config, cop)
         end
 
+        # A cop that only the `Preview` defaults disable runs again as soon as
+        # preview is turned off, so its directives are still needed.
+        def disabled_by_preview?(cop)
+          return false unless preview? && all_cop_names.include?(cop)
+
+          preview_defaults = ConfigLoader.default_configuration[cop]&.fetch('Preview', nil)
+          return false unless preview_defaults.is_a?(Hash) && preview_defaults['Enabled'] == false
+
+          !config.cop_enabled?(cop)
+        end
+
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if should_skip_line_range?(cop, line_range)
@@ -155,17 +166,29 @@ module RuboCop
           end
         end
 
-        # A `disable-next` with no statement attached (or misplaced at the end
-        # of a code line) suppresses nothing, so it is redundant by definition.
+        # A next-statement directive with no statement attached (or misplaced
+        # at the end of a code line) affects nothing, so it is redundant by
+        # definition.
         def each_detached_next_directive
           processed_source.comment_config.detached_next_directives.each do |directive|
-            directive.raw_cop_names.each { |cop| yield directive.comment, cop }
+            names = if directive.next?
+                      directive.signed_args.values.flatten
+                    else
+                      directive.raw_cop_names
+                    end
+            names.each { |cop| yield directive.comment, cop }
           end
         end
 
         def skip_directive?(comment)
+          # A cop disabled in the configuration is represented by a synthetic directive that
+          # has no comment in the source, so there is nothing to report or to remove.
+          # Its range starts at `CONFIG_DISABLED_LINE_RANGE_MIN` and runs to the end of the file,
+          # but a `pop` splits it, and the pieces in between are bounded on both sides.
+          return true if comment.is_a?(CommentConfig::ConfigDisabledCopDirectiveComment)
+
           directive = DirectiveComment.new(comment)
-          directive.push? || directive.pop?
+          directive.push? || directive.pop? || directive.next?
         end
 
         def find_redundant_directive(cop, comment, line_range, next_range)
@@ -190,11 +213,11 @@ module RuboCop
 
             comment = directive_comment(range)
 
-            next unless comment
-            # Comments disabling all cops don't count since it's reasonable
-            # to disable a few select cops first and then all cops further
-            # down in the code.
-            next if all_disabled?(comment)
+            # `push`/`next` signed arguments are not analyzed for redundancy
+            # (yet), and comments disabling all cops don't count since it's
+            # reasonable to disable a few select cops first and then all cops
+            # further down in the code.
+            next if comment.nil? || skip_directive?(comment) || all_disabled?(comment)
 
             redundant =
               if department_disabled?(cop, comment)
@@ -280,18 +303,20 @@ module RuboCop
         end
 
         def add_offense_for_entire_comment(comment, cops)
-          location = DirectiveComment.new(comment).range
+          directive = DirectiveComment.new(comment)
+          location = directive.range
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
           # An unknown cop may just not be loaded in this run (e.g. a custom
           # cop whose configuration failed to load) - removing its directive
           # would destroy something that cannot be restored, so only report.
           # A misplaced EOL `disable-next` should be moved, not deleted.
+          message = message(cop_names, enabling: directive.enable_next?)
           if any_unknown_cop?(cops) || misplaced_next_directive?(comment)
-            return add_offense(location, message: message(cop_names))
+            return add_offense(location, message: message)
           end
 
-          add_offense(location, message: message(cop_names)) do |corrector|
+          add_offense(location, message: message) do |corrector|
             remove_entire_comment(corrector, comment)
           end
         end
@@ -333,7 +358,7 @@ module RuboCop
 
         def misplaced_next_directive?(comment)
           directive = DirectiveComment.new(comment)
-          directive.disable_next? &&
+          (directive.disable_next? || directive.next? || directive.enable_next?) &&
             !processed_source.comment_config.comment_only_line?(directive.line_number)
         end
 
@@ -396,8 +421,8 @@ module RuboCop
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 
-        def message(cop_names)
-          "Unnecessary disabling of #{cop_names}."
+        def message(cop_names, enabling: false)
+          "Unnecessary #{enabling ? 'enabling' : 'disabling'} of #{cop_names}."
         end
 
         def all_cop_names

data/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb

@@ -28,6 +28,7 @@ module RuboCop
       #   end
       #
       class RedundantDirGlobSort < Base
+        include RangeHelp
         extend AutoCorrector
         extend TargetRubyVersion
 
@@ -46,8 +47,7 @@ module RuboCop
           selector = node.loc.selector
 
           add_offense(selector) do |corrector|
-            corrector.remove(selector)
-            corrector.remove(node.loc.dot)
+            autocorrect(corrector, node.loc.dot, selector)
           end
         end
 
@@ -67,6 +67,17 @@ module RuboCop
         def sort_with_comparator?(node)
           node.parent&.any_block_type? || node.last_argument&.block_pass_type?
         end
+
+        def autocorrect(corrector, dot, selector)
+          range = dot.join(selector)
+
+          if processed_source.contains_comment?(range)
+            corrector.remove(dot)
+            corrector.remove(selector)
+          else
+            corrector.remove(range_with_surrounding_space(range, side: :left))
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb

@@ -53,12 +53,22 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
+            next unless verbatim_string?(text)
+
             detect_offenses_in_tree(text, parse_regexp(text.value))
           end
         end
 
         private
 
+        # Offsets into the string's value only point at the right place in the source
+        # when the string has no escape sequences, so anything else is left alone.
+        def verbatim_string?(node)
+          return false unless node.loc?(:begin) && node.loc?(:end)
+
+          node.loc.begin.end.join(node.loc.end.begin).source == node.value
+        end
+
         # When a character class opens with a bare `]` (e.g. `[^]]`), `regexp_parser` parses
         # `[^]` / `[]` as an empty set and reports the closing `]` as a separate literal.
         # Ruby treats that `]` as the end of the class, not as an unescaped bracket,
@@ -97,7 +107,7 @@ module RuboCop
             location = range_at_index(node, expr.ts, pos)
 
             add_offense(location) do |corrector|
-              corrector.replace(location, '\]')
+              corrector.replace(location, escaped_bracket(node))
             end
           end
 
@@ -108,6 +118,13 @@ module RuboCop
           adjustment = index + offset
           node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
         end
+
+        # A double-quoted string turns `\]` into `]`, so its backslash needs escaping too.
+        def escaped_bracket(node)
+          return '\]' if node.regexp_type? || node.single_quoted? || node.percent_literal?(:q)
+
+          '\\\\]'
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -212,16 +212,23 @@ module RuboCop
         end
 
         def remove_local_variable_assignment_part(corrector, node)
-          corrector.remove(node.loc.name.begin.join(node.expression.source_range.begin))
-        end
-
-        def variable_in_loop_condition?(assignment_node, variable)
-          return false if assignment_node.each_ancestor(:any_def).any?
+          expression = node.expression
+          assignment_part = node.loc.name.begin.join(expression.source_range.begin)
 
-          loop_node = assignment_node.each_ancestor.find do |ancestor|
-            ancestor.type?(*VariableForce::LOOP_TYPES)
+          # `x = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          if expression.array_type? && !expression.bracketed?
+            corrector.replace(assignment_part, '[')
+            corrector.insert_after(expression, ']')
+          else
+            corrector.remove(assignment_part)
           end
+        end
 
+        def variable_in_loop_condition?(assignment_node, variable)
+          # A method defined inside the loop has its own scope, so the loop condition
+          # can only read the variable if the loop is nearer than any method definition.
+          loop_node = assignment_node.each_ancestor(*VariableForce::LOOP_TYPES, :any_def).first
+          return false if !loop_node || loop_node.any_def_type?
           return false unless loop_node.respond_to?(:condition)
 
           condition_node = loop_node.condition

data/lib/rubocop/cop/lint/void.rb

@@ -271,7 +271,14 @@ module RuboCop
           return if node.parent.type?(:if, :case, :when, :case_match, :in_pattern)
           return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
 
-          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+          range = range_with_surrounding_space(range: void_expression_range(node), side: :left)
+          corrector.remove(range)
+        end
+
+        def void_expression_range(node)
+          return node.source_range unless node.respond_to?(:heredoc?) && node.heredoc?
+
+          node.source_range.join(node.loc.heredoc_end)
         end
 
         def autocorrect_nonmutating_send(corrector, node, suggestion)

data/lib/rubocop/cop/lint.rb

@@ -76,6 +76,7 @@ module RuboCop
       register_cop :LiteralAssignmentInCondition, "#{__dir__}/lint/literal_assignment_in_condition"
       register_cop :LiteralInInterpolation, "#{__dir__}/lint/literal_in_interpolation"
       register_cop :Loop, "#{__dir__}/lint/loop"
+      register_cop :MisplacedMagicComment, "#{__dir__}/lint/misplaced_magic_comment"
       register_cop :MissingCopEnableDirective, "#{__dir__}/lint/missing_cop_enable_directive"
       register_cop :MissingSuper, "#{__dir__}/lint/missing_super"
       register_cop :MixedCaseRange, "#{__dir__}/lint/mixed_case_range"

data/lib/rubocop/cop/metrics/class_length.rb

@@ -40,6 +40,8 @@ module RuboCop
       class ClassLength < Base
         include CodeLength
 
+        LABEL = 'Class'
+
         def on_class(node)
           check_code_length(node)
         end
@@ -60,8 +62,8 @@ module RuboCop
 
         private
 
-        def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
 
         def find_expression_within_parent(parent)

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -48,10 +48,6 @@ module RuboCop
 
           1
         end
-
-        def count_block?(block)
-          KNOWN_ITERATING_METHODS.include? block.method_name
-        end
       end
     end
   end

data/lib/rubocop/cop/metrics/module_length.rb

@@ -38,6 +38,8 @@ module RuboCop
       class ModuleLength < Base
         include CodeLength
 
+        LABEL = 'Module'
+
         def on_module(node)
           check_code_length(node)
         end
@@ -53,8 +55,8 @@ module RuboCop
           (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
-        def message(length, max_length)
-          format('Module has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
       end
     end