gurkencheck 0.0.10 → 0.1.0

package/README.md

@@ -70,7 +70,8 @@ gurkencheck [options] <feature-files>
                           or the path to a formatter of your own
                           (default: stylish)
   -c, --config <path>     configuration file (default: .gurkencheckrc)
-  -i, --ignore <globs>    comma separated globs to skip, overriding .gurkencheckignore
+  -i, --ignore <globs>    comma separated globs to skip, overriding .gurkencheckignore;
+                          may be given more than once
   -r, --rulesdir <dir>    directory of custom rules; may be given more than once
   -l, --language <code>   dialect for files with no "# language:" header
   -w, --watch             keep running, checking again whenever a file changes
@@ -153,7 +154,9 @@ Statistics are for reading, not for failing a build — that is what the rules a
 gurkencheck stats [options] <feature-files>
 
   -f, --format <format>   output format: text, json, md (default: text)
-  -i, --ignore <globs>    comma separated globs to skip
+  -c, --config <path>     configuration file to take the language from
+                          (default: .gurkencheckrc)
+  -i, --ignore <globs>    comma separated globs to skip; may be given more than once
   -l, --language <code>   dialect for files with no "# language:" header
       --top <n>           how many entries each list shows (default: 10)
   -h, --help              show this message
@@ -244,7 +247,8 @@ created after it started is picked up too. `node_modules` and `.git` are skipped
 ```
 
 Paths in the log are relative to the directory gurkencheck ran in, which is what code
-scanning needs to match a finding to a file in the repository.
+scanning needs to match a finding to a file in the repository, so run it from the repository
+root. A file outside that directory is named by an absolute `file:` URI instead.
 
 ## Switching a rule off for one place
 
@@ -264,7 +268,7 @@ Write a comment in the feature file:
 | Directive | What it covers |
 |---|---|
 | `gurkencheck-disable-next-line` | The line directly below the comment |
-| `gurkencheck-disable` | From the comment to the end of the file, or to the next `gurkencheck-enable` |
+| `gurkencheck-disable` | From the comment to the end of the file, or to the next `gurkencheck-enable`. Written above the `Feature`, it also covers findings about the whole file, such as `file-name` |
 | `gurkencheck-enable` | Resumes the rules a `gurkencheck-disable` switched off |
 | `gurkencheck-disable-file` | The whole file, wherever the comment appears |
 
@@ -299,7 +303,7 @@ extends, and later entries in a list win over earlier ones.
 {
   "extends": "gurkencheck:recommended",
   "indentation": ["on", {"Step": 4}],
-  "no-trailing-spaces": "off"
+  "no-dupe-scenario-names": ["on", "in-feature"]
 }
 ```
 
@@ -314,9 +318,18 @@ extends, and later entries in a list win over earlier ones.
 Put one glob per line in a `.gurkencheckignore` file, or pass `--ignore` on the command
 line. Without either, `node_modules` is skipped and everything else is checked.
 
-A pattern that matches a directory skips everything below it, as in `.gitignore` and
-`.eslintignore`, so `build` is enough and you do not have to write `build/**`. Blank lines
-and lines starting with `#` are ignored.
+Patterns are read the way `.gitignore` reads them:
+
+- A pattern that matches a directory skips everything below it, so `build` is enough and
+  you do not have to write `build/**`.
+- A pattern with no slash in it, such as `build` or `*.wip.feature`, matches at any depth.
+  One with a slash, such as `features/legacy`, is anchored to the directory gurkencheck
+  runs in.
+- A trailing slash, as in `tmp/`, matches only a directory.
+- A leading `!` brings back something an earlier pattern skipped. The last pattern to match
+  decides, and nothing inside a skipped directory can be brought back.
+
+Blank lines and lines starting with `#` are ignored.
 
 ## Custom formatters
 
@@ -370,6 +383,9 @@ npx gurkencheck --rulesdir ./rules
 
 A custom rule may reuse a built-in rule's name to replace it.
 
+Every module directly inside the directory has to be a rule; TypeScript declaration files
+(`.d.ts`) are skipped. Code the rules share belongs in a subdirectory, which is not read.
+
 `run` may also be `async` and return a promise, for a rule that has to wait for
 something — reading a file, or asking an issue tracker whether a tag refers to a real
 ticket. Files are checked one after another, so rules see a predictable order.
@@ -380,7 +396,7 @@ ticket. Files are checked one after another, so rules see a predictable order.
 import {findFeatureFiles, lint, loadRules, readConfiguration} from 'gurkencheck';
 
 const rules = await loadRules();
-const config = readConfiguration('.gurkencheckrc', rules);
+const config = await readConfiguration('.gurkencheckrc', rules);
 
 if (config.ok) {
   const {files} = findFeatureFiles(['features']);
@@ -392,8 +408,11 @@ Each error carries `message`, `rule`, `line` and, where the rule knows one, `col
 both 1-based, so an editor can underline exactly the right text. Errors about a whole file
 or a whole line, such as a missing new line at the end of the file, have no `column`.
 
-Nothing in the library writes to the console or exits the process; that is the command
-line's job.
+Nothing in the library exits the process, and the parts that lint, read configuration or
+find files never write to the console; that is the command line's job. The exceptions are
+the ones whose job is printing: each formatter's `printResults`, the functions in
+`FORMATTERS`, and `runStats`, which runs the `stats` command and writes its report to
+stdout. To get the text instead, use `toJson`, `toSarif`, or `getStatsFormatter`.
 
 ## Developing
 

package/dist/config-parser.d.ts

@@ -7,15 +7,29 @@ export type ConfigurationResult = {
     configuration: Configuration;
     source: string;
     language?: string;
+    /**
+     * Every file the configuration was read from - the file itself and
+     * each one it extends, as absolute paths. What a watch has to keep an
+     * eye on to know the configuration changed.
+     */
+    files?: string[];
 } | {
     ok: false;
     message: string;
     details: string[];
 };
+/**
+ * The `language` a configuration file sets, following what it extends, or
+ * `undefined` when there is no file, it sets none, or it cannot be read.
+ *
+ * For commands that read feature files without linting them, such as
+ * `stats`: they need the dialect, but should not refuse to run over a rule
+ * setting they never use.
+ */
+export declare function readConfiguredLanguage(configPath?: string): Promise<string | undefined>;
 /**
  * Reads the configuration file at `configPath`, or the default file in the
  * working directory when no path is given. With neither, the recommended
  * rules are used.
  */
 export declare function readConfiguration(configPath: string | undefined, rules: RuleRegistry): Promise<ConfigurationResult>;
-//# sourceMappingURL=config-parser.d.ts.map

package/dist/config-parser.js

@@ -10,12 +10,12 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  * Reading and validating the configuration file.
  */
 import fs from 'node:fs';
-import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { verifyConfiguration } from './config-verifier.js';
 import { PRESETS, RECOMMENDED } from './presets.js';
 import { stripJsonComments } from './util/json.js';
+import { resolvePackage } from './util/resolve.js';
 /** The configuration file looked for when none is given on the command line. */
 export const DEFAULT_CONFIG_FILE_NAME = '.gurkencheckrc';
 /** The key naming the configurations to build on top of. */
@@ -30,7 +30,8 @@ function isConfigurationObject(value) {
 function parseFile(filePath) {
     let parsed;
     try {
-        parsed = JSON.parse(stripJsonComments(fs.readFileSync(filePath, 'utf8')));
+        // JSON.parse refuses a byte order mark, which some editors write.
+        parsed = JSON.parse(stripJsonComments(fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/u, '')));
     }
     catch (thrown) {
         throw new ConfigurationError(`Could not parse "${filePath}": ${thrown instanceof Error ? thrown.message : String(thrown)}`);
@@ -80,7 +81,7 @@ async function loadExtended(specifier, fromFile) {
     }
     let resolved;
     try {
-        resolved = createRequire(pathToFileURL(from)).resolve(specifier);
+        resolved = resolvePackage(specifier, from);
     }
     catch {
         throw new ConfigurationError(`Could not resolve the package "${specifier}", extended from "${fromFile}". Is it installed?`);
@@ -105,21 +106,60 @@ async function loadExtended(specifier, fromFile) {
  * Flattens a configuration and everything it extends into one object. What a
  * file says wins over what it extends, and later entries in an `extends` list
  * win over earlier ones.
+ *
+ * `ancestors` holds the chain of files that led here, not every file seen so
+ * far: two files extending the same base is sharing, not a cycle. `files`
+ * collects every file read along the way.
  */
-async function flatten(configuration, source, seen) {
-    if (seen.has(source)) {
+async function flatten(configuration, source, ancestors, files) {
+    if (ancestors.has(source)) {
         throw new ConfigurationError(`"${source}" ends up extending itself.`);
     }
-    seen.add(source);
+    ancestors.add(source);
+    if (!Object.hasOwn(PRESETS, source)) {
+        files.add(path.resolve(source));
+    }
     let merged = {};
-    for (const specifier of extendsList(configuration, source)) {
-        const extended = await loadExtended(specifier, source);
-        merged = { ...merged, ...(await flatten(extended.configuration, extended.source, seen)) };
+    try {
+        for (const specifier of extendsList(configuration, source)) {
+            const extended = await loadExtended(specifier, source);
+            merged = {
+                ...merged,
+                ...(await flatten(extended.configuration, extended.source, ancestors, files)),
+            };
+        }
+    }
+    finally {
+        ancestors.delete(source);
     }
     const own = { ...configuration };
     delete own[EXTENDS];
     return { ...merged, ...own };
 }
+/**
+ * The `language` a configuration file sets, following what it extends, or
+ * `undefined` when there is no file, it sets none, or it cannot be read.
+ *
+ * For commands that read feature files without linting them, such as
+ * `stats`: they need the dialect, but should not refuse to run over a rule
+ * setting they never use.
+ */
+export async function readConfiguredLanguage(configPath = DEFAULT_CONFIG_FILE_NAME) {
+    if (!fs.existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        const flattened = (await flatten(parseFile(configPath), configPath, new Set(), new Set()));
+        const language = flattened[LANGUAGE];
+        return typeof language === 'string' ? language : undefined;
+    }
+    catch (thrown) {
+        if (thrown instanceof ConfigurationError) {
+            return undefined;
+        }
+        throw thrown;
+    }
+}
 /**
  * Reads the configuration file at `configPath`, or the default file in the
  * working directory when no path is given. With neither, the recommended
@@ -145,8 +185,9 @@ export async function readConfiguration(configPath, rules) {
         configPath = DEFAULT_CONFIG_FILE_NAME;
     }
     let flattened;
+    const files = new Set();
     try {
-        flattened = await flatten(parseFile(configPath), configPath, new Set());
+        flattened = await flatten(parseFile(configPath), configPath, new Set(), files);
     }
     catch (thrown) {
         if (thrown instanceof ConfigurationError) {
@@ -172,6 +213,11 @@ export async function readConfiguration(configPath, rules) {
     if (errors.length > 0) {
         return { ok: false, message: 'Error(s) in configuration file:', details: errors };
     }
-    return { ok: true, configuration, source: configPath, ...(language === undefined ? {} : { language }) };
+    return {
+        ok: true,
+        configuration,
+        source: configPath,
+        files: [...files],
+        ...(language === undefined ? {} : { language }),
+    };
 }
-//# sourceMappingURL=config-parser.js.map

package/dist/config-verifier.d.ts

@@ -1,4 +1,3 @@
 import type { Configuration, RuleRegistry } from './types.ts';
 /** Returns a list of problems; an empty list means the file is usable. */
 export declare function verifyConfiguration(configuration: Configuration, rules: RuleRegistry): string[];
-//# sourceMappingURL=config-verifier.d.ts.map

package/dist/config-verifier.js

@@ -3,6 +3,7 @@
  * a rule name is reported once and clearly rather than silently ignored.
  */
 import { ALWAYS_ON_RULES } from './gherkin/parse.js';
+import { BUILT_IN_RULES } from './rules/index.js';
 const STATES = ['on', 'warn', 'off'];
 function describeAllowed(availableConfigs) {
     if (Array.isArray(availableConfigs)) {
@@ -15,9 +16,69 @@ function describeAllowed(availableConfigs) {
     }
     return '';
 }
-function verifySettings(ruleName, availableConfigs, settings, errors) {
+/** What a value should be, going by the default it would replace. */
+function describeType(fallback) {
+    if (Array.isArray(fallback))
+        return 'a list of strings';
+    if (typeof fallback === 'number')
+        return 'a number';
+    if (typeof fallback === 'boolean')
+        return 'true or false';
+    if (typeof fallback === 'string')
+        return 'a string';
+    return 'an object';
+}
+/**
+ * Checks each setting against the type of the default it replaces, going
+ * into nested settings. A value of the wrong type is not a matter of taste:
+ * the rule would crash on it, or quietly do something else - a string where
+ * a list belongs is read one character at a time.
+ */
+function verifyTypes(prefix, defaults, settings, path, errors) {
+    for (const [key, value] of Object.entries(settings)) {
+        if (!Object.hasOwn(defaults, key)) {
+            continue;
+        }
+        const fallback = defaults[key];
+        const name = `${path}${key}`;
+        let fits;
+        if (Array.isArray(fallback)) {
+            fits = Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+        }
+        else if (typeof fallback === 'number') {
+            fits = typeof value === 'number' && Number.isFinite(value);
+        }
+        else if (typeof fallback === 'object' && fallback !== null) {
+            fits = typeof value === 'object' && value !== null && !Array.isArray(value);
+            if (fits) {
+                for (const nested of Object.keys(value)) {
+                    if (!Object.hasOwn(fallback, nested)) {
+                        errors.push(`${prefix}"${name}" has no setting called "${nested}". Available settings: ${describeAllowed(fallback)}`);
+                    }
+                }
+                verifyTypes(prefix, fallback, value, `${name}.`, errors);
+                continue;
+            }
+        }
+        else {
+            fits = typeof value === typeof fallback;
+        }
+        if (!fits) {
+            errors.push(`${prefix}"${name}" should be ${describeType(fallback)}, not ${JSON.stringify(value)}`);
+        }
+    }
+}
+function verifySettings(rule, settings, errors) {
+    const ruleName = rule.name;
+    const availableConfigs = rule.availableConfigs;
     const prefix = `Invalid rule configuration for "${ruleName}" - `;
     if (availableConfigs === undefined) {
+        // A custom rule may read settings it never declared; a built-in one
+        // declares every setting it has, so settings for one with none are a
+        // mistake.
+        if (BUILT_IN_RULES.includes(rule)) {
+            errors.push(`${prefix}the rule has no settings, so the config should be "on", "warn" or "off"`);
+        }
         return;
     }
     if (Array.isArray(availableConfigs)) {
@@ -37,6 +98,14 @@ function verifySettings(ruleName, availableConfigs, settings, errors) {
             errors.push(`${prefix}the rule has no setting called "${key}". Available settings: ${describeAllowed(availableConfigs)}`);
         }
     }
+    const before = errors.length;
+    verifyTypes(prefix, availableConfigs, settings, '', errors);
+    // The rule's own checks assume the types are right, so they run only then.
+    if (errors.length === before && rule.verifySettings !== undefined) {
+        for (const problem of rule.verifySettings(settings)) {
+            errors.push(`${prefix}${problem}`);
+        }
+    }
 }
 /** Returns a list of problems; an empty list means the file is usable. */
 export function verifyConfiguration(configuration, rules) {
@@ -74,8 +143,7 @@ export function verifyConfiguration(configuration, rules) {
             errors.push(`${prefix}the config should have exactly 2 parts: a state and the rule's settings`);
             continue;
         }
-        verifySettings(ruleName, rule.availableConfigs, ruleConfig[1], errors);
+        verifySettings(rule, ruleConfig[1], errors);
     }
     return errors;
 }
-//# sourceMappingURL=config-verifier.js.map

package/dist/diagnostics.d.ts

@@ -31,4 +31,3 @@ export declare function collectDiagnostics(): CollectedDiagnostics;
  * other.
  */
 export declare const TO_STDERR: Diagnostics;
-//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.js

@@ -50,4 +50,3 @@ export const TO_STDERR = {
         }
     },
 };
-//# sourceMappingURL=diagnostics.js.map

package/dist/exit-codes.d.ts

@@ -7,4 +7,3 @@ export declare const EXIT_OK = 0;
 export declare const EXIT_LINT_ERRORS = 1;
 /** The command could not run: bad arguments, missing or invalid config. */
 export declare const EXIT_USAGE = 2;
-//# sourceMappingURL=exit-codes.d.ts.map

package/dist/exit-codes.js

@@ -7,4 +7,3 @@ export const EXIT_OK = 0;
 export const EXIT_LINT_ERRORS = 1;
 /** The command could not run: bad arguments, missing or invalid config. */
 export const EXIT_USAGE = 2;
-//# sourceMappingURL=exit-codes.js.map

package/dist/feature-finder.d.ts

@@ -53,4 +53,3 @@ export declare function findFeatureFileStream(patterns: readonly string[], ignor
  * every change twice.
  */
 export declare function featureRoots(patterns: readonly string[]): string[];
-//# sourceMappingURL=feature-finder.d.ts.map

package/dist/feature-finder.js

@@ -5,33 +5,51 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { uniq } from './util/collections.js';
-import { globRoot, globStream, globSync } from './util/glob.js';
+import { escapeGlob, globRoot, globStream, globSync, literalPath } from './util/glob.js';
 /** The ignore file looked for when `--ignore` is not given. */
 export const DEFAULT_IGNORE_FILE_NAME = '.gurkencheckignore';
 /** Never worth linting, and expensive to walk into. */
-export const DEFAULT_IGNORED_PATTERNS = ['node_modules/**'];
+export const DEFAULT_IGNORED_PATTERNS = ['node_modules'];
+/** The argument with forward slashes, whatever the platform writes. */
+function toSlashes(pattern) {
+    return pattern.split(path.sep).join('/');
+}
 /**
  * Expands one command line argument into a glob that only matches feature
  * files, or `undefined` when it does not name anything usable.
+ *
+ * Something that exists is taken as a name rather than as a glob, and
+ * escaped, so a file or directory whose name holds glob characters - `[wip]`,
+ * `{x}` - is still found, and a directory called `x.feature` is searched. A
+ * name without glob syntax that does not exist is reported rather than
+ * searched for: matching nothing, it would end in a clean run.
  */
 function toFeatureGlob(pattern) {
     if (pattern === '.') {
         return '**/*.feature';
     }
+    let stats;
+    try {
+        stats = fs.statSync(pattern);
+    }
+    catch {
+        stats = undefined;
+    }
+    if (stats?.isDirectory() === true) {
+        return `${escapeGlob(toSlashes(pattern)).replace(/\/+$/, '')}/**/*.feature`;
+    }
+    if (stats?.isFile() === true) {
+        return pattern.endsWith('.feature') ? escapeGlob(toSlashes(pattern)) : undefined;
+    }
+    if (literalPath(toSlashes(pattern)) !== undefined) {
+        return undefined;
+    }
     if (/\/\*\*$/.test(pattern)) {
         return `${pattern}/*.feature`;
     }
     if (pattern.endsWith('.feature')) {
         return pattern;
     }
-    try {
-        if (fs.statSync(pattern).isDirectory()) {
-            return path.join(pattern, '**/*.feature').split(path.sep).join('/');
-        }
-    }
-    catch {
-        // Reported by the caller as an invalid pattern.
-    }
     return undefined;
 }
 /** Reads the ignore file, one glob pattern per line, ignoring blank lines. */
@@ -51,6 +69,7 @@ export function readIgnorePatterns(ignoreArgument, ignoreFileName = DEFAULT_IGNO
         return [...DEFAULT_IGNORED_PATTERNS];
     }
     return contents
+        .replace(/^\uFEFF/u, '')
         .split(/\r\n|\r|\n/)
         .map((line) => line.trim())
         .filter((line) => line !== '' && !line.startsWith('#'));
@@ -145,4 +164,3 @@ export function featureRoots(patterns) {
     }
     return kept;
 }
-//# sourceMappingURL=feature-finder.js.map

package/dist/formatters/index.d.ts

@@ -60,4 +60,3 @@ export declare function getFormatter(format: string | undefined): Formatter | un
  * `printResults`, or be the function itself.
  */
 export declare function loadFormatter(format: string | undefined, cwd?: string): Promise<Formatter>;
-//# sourceMappingURL=index.d.ts.map

package/dist/formatters/index.js

@@ -9,7 +9,6 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 /**
  * Output formats.
  */
-import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { printResults as json } from './json.js';
@@ -17,6 +16,7 @@ import { printResults as junit } from './junit.js';
 import { printResults as sarif } from './sarif.js';
 import { printResults as stylish, startRun as streamStylish } from './stylish.js';
 import { printResults as tap, startRun as streamTap } from './tap.js';
+import { resolvePackage } from '../util/resolve.js';
 /** The formats accepted by `--format` without having to be loaded. */
 export const FORMATTERS = {
     stylish,
@@ -80,7 +80,7 @@ async function loadFormatterModule(specifier, cwd) {
     }
     else {
         try {
-            resolved = createRequire(pathToFileURL(from)).resolve(specifier);
+            resolved = resolvePackage(specifier, from);
         }
         catch {
             throw new Error(`Unsupported format "${specifier}". Use one of ${Object.keys(FORMATTERS).join(', ')}, ` +
@@ -113,4 +113,3 @@ export async function loadFormatter(format, cwd = process.cwd()) {
     }
     return formatter;
 }
-//# sourceMappingURL=index.js.map

package/dist/formatters/json.d.ts

@@ -28,4 +28,3 @@ export interface JsonResult {
 export declare function toJson(results: readonly FileResult[]): JsonResult[];
 /** Writes the results as a single line of JSON. */
 export declare function printResults(results: readonly FileResult[]): void;
-//# sourceMappingURL=json.d.ts.map

package/dist/formatters/json.js

@@ -28,4 +28,3 @@ export function toJson(results) {
 export function printResults(results) {
     console.log(JSON.stringify(toJson(results)));
 }
-//# sourceMappingURL=json.js.map

package/dist/formatters/junit.d.ts

@@ -1,17 +1,5 @@
-/**
- * JUnit XML, the report format CI servers such as Jenkins and TeamCity read.
- *
- * Each file becomes a test suite and each finding a test case, so a build
- * shows one failing test per problem with its message and position, rather
- * than one opaque failure per file. A file with nothing to report still
- * contributes a passing test case, so the report says what was checked.
- *
- * A warning does not fail the run, so it is reported as a passing test case
- * carrying its message, rather than as a failure the build would trip over.
- */
 import type { FileResult } from '../types.ts';
 /** Renders the results as a JUnit report. */
-export declare function format(results: readonly FileResult[]): string;
+export declare function format(results: readonly FileResult[], cwd?: string): string;
 /** Writes the JUnit report to stdout. */
 export declare function printResults(results: readonly FileResult[]): void;
-//# sourceMappingURL=junit.d.ts.map

package/dist/formatters/junit.js

@@ -1,3 +1,15 @@
+/**
+ * JUnit XML, the report format CI servers such as Jenkins and TeamCity read.
+ *
+ * Each file becomes a test suite and each finding a test case, so a build
+ * shows one failing test per problem with its message and position, rather
+ * than one opaque failure per file. A file with nothing to report still
+ * contributes a passing test case, so the report says what was checked.
+ *
+ * A warning does not fail the run, so it is reported as a passing test case
+ * carrying its message, rather than as a failure the build would trip over.
+ */
+import path from 'node:path';
 import { attributes, escapeXml, indent, XML_DECLARATION } from '../util/xml.js';
 function severityOf(error) {
     return error.severity ?? 'error';
@@ -10,32 +22,46 @@ function classNameFor(filePath) {
         .filter((part) => part !== '' && part !== '.')
         .join('.');
 }
+/**
+ * The path to show for a file: relative to the working directory, as a CI
+ * server shows the repository, so suites read `features/Login.feature` and
+ * group as `features.Login` rather than by where the build machine keeps its
+ * checkout. A file outside the working directory keeps its absolute path.
+ */
+function displayPath(filePath, cwd) {
+    const relative = path.relative(cwd, filePath);
+    if (relative === '' || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        return filePath;
+    }
+    return relative.split(path.sep).join('/');
+}
 function positionOf(error) {
     return error.column === undefined ? `${error.line}` : `${error.line}:${error.column}`;
 }
-function testCase(result, error) {
+function testCase(filePath, error) {
     const open = `<testcase${attributes({
         name: `${error.rule} (${positionOf(error)})`,
-        classname: classNameFor(result.filePath),
+        classname: classNameFor(filePath),
     })}>`;
-    const detail = escapeXml(`${result.filePath}:${positionOf(error)} (${error.rule}) ${error.message}`);
+    const detail = escapeXml(`${filePath}:${positionOf(error)} (${error.rule}) ${error.message}`);
     const body = severityOf(error) === 'warning'
         ? `<system-out>${detail}</system-out>`
         : `<failure${attributes({ message: error.message, type: error.rule })}>${detail}</failure>`;
     return `${open}\n${indent(body, 1)}\n</testcase>`;
 }
-function testSuite(result) {
+function testSuite(result, cwd) {
+    const filePath = displayPath(result.filePath, cwd);
     const failures = result.errors.filter((error) => severityOf(error) === 'error').length;
     const cases = result.errors.length > 0
-        ? result.errors.map((error) => testCase(result, error))
+        ? result.errors.map((error) => testCase(filePath, error))
         : [
             `<testcase${attributes({
-                name: result.filePath,
-                classname: classNameFor(result.filePath),
+                name: filePath,
+                classname: classNameFor(filePath),
             })}/>`,
         ];
     const open = `<testsuite${attributes({
-        name: result.filePath,
+        name: filePath,
         tests: Math.max(result.errors.length, 1),
         failures,
         errors: 0,
@@ -44,12 +70,12 @@ function testSuite(result) {
     return `${open}\n${indent(cases.join('\n'), 1)}\n</testsuite>`;
 }
 /** Renders the results as a JUnit report. */
-export function format(results) {
+export function format(results, cwd = process.cwd()) {
     const tests = results.reduce((total, result) => total + Math.max(result.errors.length, 1), 0);
     const failures = results.reduce((total, result) => total + result.errors.filter((error) => severityOf(error) === 'error').length, 0);
     const body = [
         `<testsuites${attributes({ name: 'gurkencheck', tests, failures, errors: 0 })}>`,
-        ...results.map((result) => indent(testSuite(result), 1)),
+        ...results.map((result) => indent(testSuite(result, cwd), 1)),
         '</testsuites>',
     ].join('\n');
     return `${XML_DECLARATION}\n${body}`;
@@ -58,4 +84,3 @@ export function format(results) {
 export function printResults(results) {
     console.log(format(results));
 }
-//# sourceMappingURL=junit.js.map

package/dist/formatters/sarif.d.ts

@@ -3,4 +3,3 @@ import type { FileResult } from '../types.ts';
 export declare function toSarif(results: readonly FileResult[], cwd?: string): unknown;
 /** Writes the SARIF log to stdout. */
 export declare function printResults(results: readonly FileResult[]): void;
-//# sourceMappingURL=sarif.d.ts.map