@tony.ganchev/eslint-plugin-header 3.1.11 → 3.2.0

package/lib/comment-parser.js

@@ -33,8 +33,8 @@ const assert = require("assert");
  * This is a really simple and dumb parser, that looks just for a
  * single kind of comment. It won't detect multiple block comments.
  * @param {string} commentText comment text.
- * @returns {['block' | 'line', string | string[]]} comment type and comment
- *                                                  content broken into lines.
+ * @returns {['block' | 'line', string[]]} comment type and comment content
+ *                                         broken into lines.
  */
 module.exports = function commentParser(commentText) {
     assert.strictEqual(typeof commentText, "string");
@@ -46,7 +46,7 @@ module.exports = function commentParser(commentText) {
             text.split(/\r?\n/).map((line) => line.substring(2))
         ];
     } else if (text.startsWith("/*") && text.endsWith("*/")) {
-        return ["block", text.substring(2, text.length - 2)];
+        return ["block", text.substring(2, text.length - 2).split(/\r?\n/)];
     } else {
         throw new Error(
             "Could not parse comment file: the file must contain either just line comments (//) or a single block " +

package/lib/rules/eslint-utils.js

@@ -0,0 +1,42 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2025-present Tony Ganchev and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the “Software”), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+"use strict";
+
+/**
+ * @typedef {import('eslint').Rule.RuleContext} RuleContext
+ * @typedef {import('eslint').SourceCode} SourceCode
+ */
+
+module.exports = {
+    /**
+     * Provides compatibility wrapper for ESLint 7 through 10 for getting the
+     * full source code object from the execution context.
+     * @param {RuleContext} context ESLint execution context.
+     * @returns {SourceCode} the source-code object.
+     */
+    contextSourceCode: function(context) {
+        return context.sourceCode || context.getSourceCode();
+    }
+};

package/lib/rules/header.js

@@ -28,8 +28,9 @@ const assert = require("assert");
 const fs = require("fs");
 const os = require("os");
 const commentParser = require("../comment-parser");
+const { contextSourceCode } = require("./eslint-utils");
 const { description, recommended, url } = require("./header.docs");
-const { commentTypeOptions, lineEndingOptions, schema } = require("./header.schema");
+const { lineEndingOptions, commentTypeOptions, schema } = require("./header.schema");
 
 /**
  * Import type definitions.
@@ -46,18 +47,40 @@ const { commentTypeOptions, lineEndingOptions, schema } = require("./header.sche
  */
 
 /**
- * Local type defintions.
- * @typedef {string | { pattern: string, template?: string }} HeaderLine
+ * Local type definitions.
+ * @typedef {{ pattern: string | RegExp, template?: string }} HeaderLinePattern
+ * @typedef {string | RegExp | HeaderLinePattern} HeaderLine
  * @typedef {(HeaderLine | HeaderLine[])} HeaderLines
- * @typedef {{ lineEndings: ('unix' | 'windows') }} HeaderSettings
+ * @typedef {{ lineEndings?: ('unix' | 'windows' | 'os') }} HeaderSettings
  * @typedef {
  *  [string]
  *  | [string, HeaderSettings]
- *  | [('block' | 'line') | HeaderLines ]
- *  | [('block' | 'line') | HeaderLines | HeaderSettings]
- *  | [('block' | 'line') | HeaderLines | number ]
- *  | [('block' | 'line') | HeaderLines | number | HeaderSettings]
- * } HeaderOptions
+ *  | [('block' | 'line'), HeaderLines ]
+ *  | [('block' | 'line'), HeaderLines, HeaderSettings]
+ *  | [('block' | 'line'), HeaderLines, number ]
+ *  | [('block' | 'line'), HeaderLines, number, HeaderSettings]
+ * } LegacyHeaderOptions
+ * @typedef {
+ *  {
+ *      file: string,
+ *      encoding?: string
+ *  }
+ * } FileBasedConfig
+ * @typedef {
+ *  {
+ *      commentType: 'line' | 'block',
+ *      lines: HeaderLine[]
+ *  }
+ * } LinesBasedConfig
+ * @typedef {{ minimum?: number }} TrailingEmptyLines
+ * @typedef {
+ *  {
+ *      header: FileBasedConfig | LinesBasedConfig,
+ *      trailingEmptyLines?: TrailingEmptyLines
+ *  }
+ *  & HeaderSettings
+ * } NewHeaderOptions
+ * @typedef {LegacyHeaderOptions | [NewHeaderOptions]} HeaderOptions
  */
 
 /**
@@ -68,7 +91,8 @@ const { commentTypeOptions, lineEndingOptions, schema } = require("./header.sche
  *                    object or `false` otherwise.
  */
 function isPattern(object) {
-    return typeof object === "object" && Object.prototype.hasOwnProperty.call(object, "pattern");
+    return typeof object === "object"
+        && (object instanceof RegExp || Object.prototype.hasOwnProperty.call(object, "pattern"));
 }
 
 /**
@@ -90,7 +114,7 @@ function match(actual, expected) {
 /**
  * Remove Unix she-bangs from the list of comments.
  * @param {Comment[]} comments the list of comment lines.
- * @returns {Comment[]} the list of comments with containing all incomming
+ * @returns {Comment[]} the list of comments with containing all incoming
  *                      comments from `comments` with the shebang comments
  *                      omitted.
  */
@@ -106,17 +130,18 @@ function excludeShebangs(comments) {
  * check if they are at the start of the file since that is already checked by
  * `hasHeader()`.
  * @param {RuleContext} context ESLint execution environment.
- * @param {Program} node ESLint AST treee node being processed.
+ * @param {Program} node ESLint AST tree node being processed.
  * @returns {Comment[]} lines that constitute the leading comment.
  */
 function getLeadingComments(context, node) {
-    const all = excludeShebangs(context.sourceCode.getAllComments(node.body.length ? node.body[0] : node));
+    const sourceCode = contextSourceCode(context);
+    const all = excludeShebangs(sourceCode.getAllComments(node.body.length ? node.body[0] : node));
     if (all[0].type.toLowerCase() === commentTypeOptions.block) {
         return [all[0]];
     }
     let i = 1;
     for (; i < all.length; ++i) {
-        const txt = context.sourceCode.text.slice(all[i - 1].range[1], all[i].range[0]);
+        const txt = sourceCode.text.slice(all[i - 1].range[1], all[i].range[0]);
         if (!txt.match(/^(\r\n|\r|\n)$/)) {
             break;
         }
@@ -186,15 +211,16 @@ function leadingEmptyLines(src) {
 function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
     return function(fixer) {
         let insertPos = 0;
-        let newHeader = genCommentBody(commentType, headerLines, eol, numNewlines);
-        if (context.sourceCode.text.startsWith("#!")) {
-            const firstNewLinePos = context.sourceCode.text.indexOf("\n");
-            insertPos = firstNewLinePos === -1 ? context.sourceCode.text.length : firstNewLinePos + 1;
+        let newHeader = genCommentBody(commentType, headerLines, eol);
+        const sourceCode = contextSourceCode(context);
+        if (sourceCode.text.startsWith("#!")) {
+            const firstNewLinePos = sourceCode.text.indexOf("\n");
+            insertPos = firstNewLinePos === -1 ? sourceCode.text.length : firstNewLinePos + 1;
             if (firstNewLinePos === -1) {
                 newHeader = eol + newHeader;
             }
         }
-        const numEmptyLines = leadingEmptyLines(context.sourceCode.text.substring(insertPos));
+        const numEmptyLines = leadingEmptyLines(sourceCode.text.substring(insertPos));
         const additionalEmptyLines = Math.max(0, numNewlines - numEmptyLines);
         newHeader += eol.repeat(additionalEmptyLines);
         return fixer.insertTextBeforeRange(
@@ -219,7 +245,7 @@ function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
 function genReplaceFixer(commentType, context, leadingComments, headerLines, eol, numNewlines) {
     return function(fixer) {
         const commentRange = genCommentsRange(leadingComments);
-        const emptyLines = leadingEmptyLines(context.sourceCode.text.substring(commentRange[1]));
+        const emptyLines = leadingEmptyLines(contextSourceCode(context).text.substring(commentRange[1]));
         const missingNewlines = Math.max(0, numNewlines - emptyLines);
         const eols = eol.repeat(missingNewlines);
         return fixer.replaceTextRange(
@@ -248,39 +274,25 @@ function genEmptyLinesFixer(leadingComments, eol, missingEmptyLinesCount) {
     };
 }
 
-/**
- * Finds the option parameter within the list of rule config options.
- * @param {HeaderOptions} options the config options passed to the rule.
- * @returns {HeaderSettings | null} the settings parameter or `null` if no such
- *                                  is defined.
- */
-function findSettings(options) {
-    const lastOption = options[options.length - 1];
-    if (typeof lastOption === "object" && !Array.isArray(lastOption) && lastOption !== null
-        && !Object.prototype.hasOwnProperty.call(lastOption, "pattern")) {
-        return lastOption;
-    }
-    return null;
-}
-
 /**
  * Returns the used line-termination characters per the rule's config if any or
  * else based on the runtime environments.
- * @param {HeaderOptions} options rule configuration.
+ * @param {'os' | 'unix' | 'windows'} style line-ending styles.
  * @returns {'\n' | '\r\n'} the correct line ending characters for the
- * environment.
+ *                          environment.
  */
-function getEOL(options) {
-    const settings = findSettings(options);
-    if (settings) {
-        if (settings.lineEndings === lineEndingOptions.unix) {
+function getEol(style) {
+    assert.strictEqual(Object.prototype.hasOwnProperty.call(lineEndingOptions, style), true,
+        "lineEnding style should have been populated in normalizeOptions().");
+    switch (style) {
+        case lineEndingOptions.unix:
             return "\n";
-        }
-        if (settings.lineEndings === lineEndingOptions.windows) {
+        case lineEndingOptions.windows:
             return "\r\n";
-        }
+        case lineEndingOptions.os:
+        default:
+            return os.EOL;
     }
-    return os.EOL;
 }
 
 /**
@@ -294,6 +306,134 @@ function hasHeader(src) {
     return srcWithoutShebang.startsWith("/*") || srcWithoutShebang.startsWith("//");
 }
 
+/**
+ * asserts on an expression and adds template texts to the failure message.
+ * Helper to write cleaner code.
+ * @param {boolean} condition assert condition.
+ * @param {string} message assert message on violation.
+ */
+function schemaAssert(condition, message) {
+    assert.strictEqual(condition, true, message + " - should have been handled by eslint schema validation.");
+}
+
+/**
+ * Ensures that if legacy options as defined in the original
+ * `eslint-plugin-header` are used, they'd be converted to the new object-based
+ * configuration. This is not a normalized internal representation of the
+ * options in that some settings are still union types and unspecified
+ * properties are not replaced by defaults. If the options follow the new
+ * format, a simple seep copy would be returned.
+ * @param {HeaderOptions} originalOptions the options as configured by the user.
+ * @returns {NewHeaderOptions} the transformed new-style options with no
+ *                             normalization.
+ */
+function transformLegacyOptions(originalOptions) {
+    schemaAssert(originalOptions?.length > 0,
+        "header options are required (at least one in addition to the severity)");
+    schemaAssert(originalOptions.length <= 4,
+        "header options should not be more than four (five including issue severity)");
+    if (originalOptions.length === 1 && typeof originalOptions[0] === "object") {
+        // The user chose to use the new-style config. We pass a copy of the
+        // incoming sole option to not mess with ESLint not relying on the old
+        // values of the option.
+        return structuredClone(originalOptions[0]);
+    }
+    // The user chose the legacy-style config. Transform them to new-style
+    // config.
+    schemaAssert(typeof originalOptions[0] === "string",
+        "first header option after severity should be either a filename or 'block' | 'line'");
+    /** @type {NewHeaderOptions} */
+    const transformedOptions = {};
+    // populate header
+    if (
+        originalOptions.length === 1
+        || (
+            originalOptions.length === 2
+            && typeof originalOptions[1] === "object"
+            && !Array.isArray(originalOptions[1])
+            && !isPattern(originalOptions[1])
+        )) {
+        transformedOptions.header = { file: originalOptions[0], encoding: "utf8" };
+    } else {
+        schemaAssert(Object.prototype.hasOwnProperty.call(commentTypeOptions, originalOptions[0]),
+            "Only 'block' or 'line' is accepted as comment type");
+        schemaAssert(
+            typeof originalOptions[1] === "string"
+            || Array.isArray(originalOptions[1])
+            || isPattern(originalOptions[1]),
+            "second header option after severity should be a string, a pattern, or an array of the previous two");
+        transformedOptions.header = {
+            commentType: originalOptions[0],
+            lines: Array.isArray(originalOptions[1]) ? originalOptions[1] : [originalOptions[1]]
+        };
+    }
+    // configure required line settings
+    if (originalOptions.length >= 3) {
+        if (typeof originalOptions[2] === "number") {
+            transformedOptions.trailingEmptyLines = { minimum: originalOptions[2] };
+            if (originalOptions.length === 4) {
+                schemaAssert(typeof originalOptions[3] === "object",
+                    "Fourth header option after severity should be either number of required trailing empty lines or " +
+                    "a settings object");
+                Object.assign(transformedOptions, originalOptions[3]);
+            }
+        } else {
+            schemaAssert(typeof originalOptions[2] === "object",
+                "Third header option after severity should be either number of required trailing empty lines or a " +
+                "settings object");
+            Object.assign(transformedOptions, originalOptions[2]);
+        }
+    }
+    return transformedOptions;
+}
+
+/**
+ * Transforms a set of new-style options adding defaults and standardizing on
+ * one of multiple config styles.
+ * @param {NewHeaderOptions} originalOptions new-style options to normalize.
+ * @returns {NewHeaderOptions} normalized options.
+ */
+function normalizeOptions(originalOptions) {
+    const options = structuredClone(originalOptions);
+
+    if (options.header.file) {
+        const text = fs.readFileSync(originalOptions.header.file, originalOptions.header.encoding || "utf8");
+        const [commentType, lines] = commentParser(text);
+        options.header = { commentType, lines };
+    }
+
+    options.header.lines = options.header.lines.flatMap(
+        (line) => {
+            if (typeof line === "string") {
+                return line.split(/\r?\n/);
+            }
+            if (line instanceof RegExp) {
+                return [{ pattern: line }];
+            }
+            assert.ok(Object.prototype.hasOwnProperty.call(line, "pattern"));
+            const pattern = line.pattern instanceof RegExp ? line.pattern : new RegExp(line.pattern);
+            if (Object.prototype.hasOwnProperty.call(line, "template")) {
+                return [{
+                    pattern,
+                    template: line.template
+                }];
+            }
+            return [{ pattern }];
+        });
+
+    if (!options.lineEndings) {
+        options.lineEndings = "os";
+    }
+
+    if (!options.trailingEmptyLines) {
+        options.trailingEmptyLines = {};
+    }
+    if (typeof options.trailingEmptyLines.minimum !== "number") {
+        options.trailingEmptyLines.minimum = 1;
+    }
+    return options;
+}
+
 /**
  * Calculates the source location of the violation that not enough empty lines
  * follow the header.
@@ -328,7 +468,15 @@ module.exports = {
         },
         fixable: "whitespace",
         schema,
-        defaultOptions: [{}],
+        defaultOptions: [
+            /** @type {HeaderOptions} */
+            {
+                lineEndings: lineEndingOptions.os,
+                trailingEmptyLines: {
+                    minimum: 1
+                }
+            }
+        ],
         messages: {
             headerLineMismatchAtPos: "header line does not match expected after this position; expected: {{expected}}",
             headerLineTooLong: "header line longer than expected",
@@ -348,46 +496,26 @@ module.exports = {
      * @returns {NodeListener} the rule definition.
      */
     create: function(context) {
-        let options = context.options;
-        const numNewlines = options.length > 2 && typeof options[2] === "number" ? options[2] : 1;
-        const eol = getEOL(options);
-
-        // If just one option then read comment from file
-        if (options.length === 1 || (options.length === 2 && findSettings(options))) {
-            const text = fs.readFileSync(context.options[0], "utf8");
-            options = commentParser(text);
-        }
 
-        const commentType = options[0].toLowerCase();
-        /** @type {(string | RegExp)[]} */
-        let headerLines;
+        const newStyleOptions = transformLegacyOptions(context.options);
+        const options = normalizeOptions(newStyleOptions);
+
+        const eol = getEol(options.lineEndings);
+
         let fixLines = [];
         // If any of the lines are regular expressions, then we can't
         // automatically fix them. We set this to true below once we
         // ensure none of the lines are of type RegExp
-        let canFix = false;
-        if (Array.isArray(options[1])) {
-            canFix = true;
-            headerLines = options[1].map(function(line) {
-                const isRegex = isPattern(line);
-                // Can only fix regex option if a template is also provided
-                if (isRegex && !line.template) {
-                    canFix = false;
-                }
-                fixLines.push(line.template || line);
-                return isRegex ? new RegExp(line.pattern) : line;
-            });
-        } else if (isPattern(options[1])) {
-            const line = options[1];
-            headerLines = [new RegExp(line.pattern)];
+        let canFix = true;
+        const headerLines = options.header.lines.map(function(line) {
+            const isRegex = isPattern(line);
+            // Can only fix regex option if a template is also provided
+            if (isRegex && !line.template) {
+                canFix = false;
+            }
             fixLines.push(line.template || line);
-            // Same as above for regex and template
-            canFix = !!line.template;
-        } else {
-            canFix = true;
-            headerLines = options[1].split(/\r?\n/);
-            fixLines = headerLines;
-        }
+            return isRegex ? line.pattern : line;
+        });
 
         return {
             /**
@@ -397,8 +525,9 @@ module.exports = {
              * @returns {void}
              */
             Program: function(node) {
-                if (!hasHeader(context.sourceCode.text)) {
-                    const hasShebang = context.sourceCode.text.startsWith("#!");
+                const sourceCode = contextSourceCode(context);
+                if (!hasHeader(sourceCode.text)) {
+                    const hasShebang = sourceCode.text.startsWith("#!");
                     const line = hasShebang ? 2 : 1;
                     context.report({
                         loc: {
@@ -412,13 +541,19 @@ module.exports = {
                             }
                         },
                         messageId: "missingHeader",
-                        fix: genPrependFixer(commentType, context, fixLines, eol, numNewlines)
+                        fix: genPrependFixer(
+                            options.header.commentType,
+                            context,
+                            fixLines,
+                            eol,
+                            options.trailingEmptyLines.minimum)
                     });
                     return;
                 }
+
                 const leadingComments = getLeadingComments(context, node);
 
-                if (leadingComments[0].type.toLowerCase() !== commentType) {
+                if (leadingComments[0].type.toLowerCase() !== options.header.commentType) {
                     context.report({
                         loc: {
                             start: leadingComments[0].loc.start,
@@ -426,15 +561,21 @@ module.exports = {
                         },
                         messageId: "incorrectCommentType",
                         data: {
-                            commentType: commentType
+                            commentType: options.header.commentType
                         },
                         fix: canFix
-                            ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines)
+                            ? genReplaceFixer(
+                                options.header.commentType,
+                                context,
+                                leadingComments,
+                                fixLines,
+                                eol,
+                                options.trailingEmptyLines.minimum)
                             : null
                     });
                     return;
                 }
-                if (commentType === commentTypeOptions.line) {
+                if (options.header.commentType === commentTypeOptions.line) {
                     if (headerLines.length === 1) {
                         const leadingCommentValues = leadingComments.map((c) => c.value);
                         if (
@@ -448,7 +589,13 @@ module.exports = {
                                 },
                                 messageId: "incorrectHeader",
                                 fix: canFix
-                                    ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines)
+                                    ? genReplaceFixer(
+                                        options.header.commentType,
+                                        context,
+                                        leadingComments,
+                                        fixLines,
+                                        eol,
+                                        options.trailingEmptyLines.minimum)
                                     : null
                             });
                             return;
@@ -466,12 +613,12 @@ module.exports = {
                                     },
                                     fix: canFix
                                         ? genReplaceFixer(
-                                            commentType,
+                                            options.header.commentType,
                                             context,
                                             leadingComments,
                                             fixLines,
                                             eol,
-                                            numNewlines)
+                                            options.trailingEmptyLines.minimum)
                                         : null
                                 });
                                 return;
@@ -494,12 +641,12 @@ module.exports = {
                                                 expected: headerLines[i].substring(j)
                                             },
                                             fix: genReplaceFixer(
-                                                commentType,
+                                                options.header.commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                numNewlines)
+                                                options.trailingEmptyLines.minimum)
                                         });
                                         return;
                                     }
@@ -515,12 +662,12 @@ module.exports = {
                                         },
                                         fix: canFix
                                             ? genReplaceFixer(
-                                                commentType,
+                                                options.header.commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                numNewlines)
+                                                options.trailingEmptyLines.minimum)
                                             : null
                                     });
                                     return;
@@ -537,12 +684,12 @@ module.exports = {
                                         messageId: "headerLineTooLong",
                                         fix: canFix
                                             ? genReplaceFixer(
-                                                commentType,
+                                                options.header.commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                numNewlines)
+                                                options.trailingEmptyLines.minimum)
                                             : null
                                     });
                                     return;
@@ -563,12 +710,12 @@ module.exports = {
                                         },
                                         fix: canFix
                                             ? genReplaceFixer(
-                                                commentType,
+                                                options.header.commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                numNewlines)
+                                                options.trailingEmptyLines.minimum)
                                             : null
                                     });
                                     return;
@@ -577,15 +724,15 @@ module.exports = {
                         }
                     }
 
-                    const actualLeadingEmptyLines = leadingEmptyLines(
-                        context.sourceCode.text.substring(leadingComments[headerLines.length - 1].range[1]));
-                    const missingEmptyLines = numNewlines - actualLeadingEmptyLines;
+                    const actualLeadingEmptyLines =
+                        leadingEmptyLines(sourceCode.text.substring(leadingComments[headerLines.length - 1].range[1]));
+                    const missingEmptyLines = options.trailingEmptyLines.minimum - actualLeadingEmptyLines;
                     if (missingEmptyLines > 0) {
                         context.report({
                             loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
                             messageId: "noNewlineAfterHeader",
                             data: {
-                                expected: numNewlines,
+                                expected: options.trailingEmptyLines.minimum,
                                 actual: actualLeadingEmptyLines
                             },
                             fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
@@ -711,21 +858,27 @@ module.exports = {
                         messageId: errorMessageId,
                         data: errorMessageData,
                         fix: canFix
-                            ? genReplaceFixer(commentType, context, leadingComments, fixLines, eol, numNewlines)
+                            ? genReplaceFixer(
+                                options.header.commentType,
+                                context,
+                                leadingComments,
+                                fixLines,
+                                eol,
+                                options.trailingEmptyLines.minimum)
                             : null
                     });
                     return;
                 }
 
-                const actualLeadingEmptyLines = leadingEmptyLines(
-                    context.sourceCode.text.substring(leadingComments[0].range[1]));
-                const missingEmptyLines = numNewlines - actualLeadingEmptyLines;
+                const actualLeadingEmptyLines =
+                    leadingEmptyLines(sourceCode.text.substring(leadingComments[0].range[1]));
+                const missingEmptyLines = options.trailingEmptyLines.minimum - actualLeadingEmptyLines;
                 if (missingEmptyLines > 0) {
                     context.report({
                         loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
                         messageId: "noNewlineAfterHeader",
                         data: {
-                            expected: numNewlines,
+                            expected: options.trailingEmptyLines.minimum,
                             actual: actualLeadingEmptyLines
                         },
                         fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
@@ -735,3 +888,4 @@ module.exports = {
         };
     }
 };
+