@controlplane/cli/dist/src/image/remote/folder/ignore.corpus.js

Control Plane Corporation CLI

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CONFORMANCE_CORPUS = void 0;
// SECTION - Functions
/**
 * Builds docker-mode rules from .dockerignore lines.
 *
 * @param {string[]} lines - The .dockerignore lines.
 * @returns {IgnoreRules} The docker rules.
 */
function dockerRules(lines) {
    return { kind: 'docker', content: lines.join('\n'), source: '.dockerignore' };
}
/**
 * Builds git-mode rules from one or more .gitignore scopes.
 *
 * @param {CorpusGitScope[]} scopes - The scope directories and their lines.
 * @returns {IgnoreRules} The git rules.
 */
function gitRules(scopes) {
    const mapped = scopes.map((scope) => ({
        dir: scope.dir,
        content: scope.lines.join('\n'),
        source: scope.dir === '' ? '.gitignore' : `${scope.dir}/.gitignore`,
    }));
    return { kind: 'git', scopes: mapped };
}
// !SECTION
// ANCHOR - Docker Ground Truth
// Verdicts come from real docker builds; regenerate with the ground-truth harness.
const DOCKER_TRUTH = 'docker build 29.6.2 (BuildKit), 2026-07-24';
const DOCKER_GROUPS = [
    {
        name: 'whitelist star + !dist/** re-includes contents',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['*', '!dist/**']),
        cases: [
            { path: 'dist/app.js', excluded: false },
            { path: 'dist/sub/lib.js', excluded: false },
            { path: 'README.md', excluded: true },
        ],
    },
    {
        name: 'whitelist star + !dist/ re-includes the directory',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['*', '!dist/']),
        cases: [
            { path: 'dist/app.js', excluded: false },
            { path: 'README.md', excluded: true },
        ],
    },
    {
        name: 'whitelist star + !dist re-includes the directory',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['*', '!dist']),
        cases: [
            { path: 'dist/app.js', excluded: false },
            { path: 'README.md', excluded: true },
        ],
    },
    {
        name: 'negation re-includes one file under an excluded directory',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['sub', '!sub/keep.txt']),
        cases: [
            { path: 'sub/keep.txt', excluded: false },
            { path: 'sub/other.txt', excluded: true },
            { path: 'root.txt', excluded: false },
        ],
    },
    {
        name: 'character classes match like Go filepath.Match',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['file[12].txt']),
        cases: [
            { path: 'file1.txt', excluded: true },
            { path: 'file2.txt', excluded: true },
            { path: 'fileX.txt', excluded: false },
            { path: 'file[12].txt', excluded: false },
        ],
    },
    {
        name: 'a trailing slash still matches a plain file',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['logs/']),
        cases: [
            { path: 'logs', excluded: true },
            { path: 'keep.txt', excluded: false },
        ],
    },
    {
        name: 'an embedded ** crosses whole segments, not characters',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['a**z']),
        cases: [
            { path: 'abz', excluded: false },
            { path: 'a/deep/z', excluded: true },
            { path: 'keep.txt', excluded: false },
        ],
    },
    {
        name: 'a leading **/ matches at any depth',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['**/temp']),
        cases: [
            { path: 'temp', excluded: true },
            { path: 'a/b/temp', excluded: true },
            { path: 'temporary', excluded: false },
        ],
    },
    {
        name: 'matching is case-sensitive',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['*.PDF']),
        cases: [
            { path: 'doc.pdf', excluded: false },
            { path: 'doc2.PDF', excluded: true },
        ],
    },
    {
        name: 'a question mark matches exactly one character',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['temp?']),
        cases: [
            { path: 'tempa', excluded: true },
            { path: 'temp', excluded: false },
            { path: 'temp12', excluded: false },
        ],
    },
    {
        name: 'a mid-pattern /**/ also matches zero directories',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['src/**/x']),
        cases: [
            { path: 'src/x', excluded: true },
            { path: 'src/a/b/x', excluded: true },
            { path: 'src/ax', excluded: false },
        ],
    },
    {
        name: 'patterns anchor to the context root',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['dist']),
        cases: [
            { path: 'dist/g.js', excluded: true },
            { path: 'web/dist/f.js', excluded: false },
            { path: 'keep.txt', excluded: false },
        ],
    },
    {
        name: 'the docs whitelist example: star + !README.md',
        truth: DOCKER_TRUTH,
        rules: dockerRules(['*', '!README.md']),
        cases: [
            { path: 'README.md', excluded: false },
            { path: 'other.txt', excluded: true },
        ],
    },
];
// ANCHOR - Git Ground Truth
// Verdicts generated from `git check-ignore` with a hermetic config, 2026-07-24.
const GIT_TRUTH = 'git check-ignore, 2026-07-24';
const GIT_GROUPS = [
    {
        name: 'a bare name matches at any depth',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['node_modules'] }]),
        cases: [
            { path: 'node_modules/x.js', excluded: true },
            { path: 'web/node_modules/y.js', excluded: true },
            { path: 'src/app.js', excluded: false },
        ],
    },
    {
        name: 'a trailing slash matches directories only',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['build/'] }]),
        cases: [
            { path: 'build', isDir: false, excluded: false },
            { path: 'build', isDir: true, excluded: true },
            { path: 'build/f.txt', excluded: true },
            { path: 'keep.txt', excluded: false },
        ],
    },
    {
        name: 'a leading slash anchors to the root',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['/anchored.txt'] }]),
        cases: [
            { path: 'anchored.txt', excluded: true },
            { path: 'sub/anchored.txt', excluded: false },
        ],
    },
    {
        name: 'no re-include beneath an excluded directory',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['sub/', '!sub/keep.txt'] }]),
        cases: [
            { path: 'sub/keep.txt', excluded: true },
            { path: 'sub/other.txt', excluded: true },
        ],
    },
    {
        name: 're-include works when only the contents are excluded',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['sub/*', '!sub/keep.txt'] }]),
        cases: [
            { path: 'sub/keep.txt', excluded: false },
            { path: 'sub/other.txt', excluded: true },
        ],
    },
    {
        name: 'nested .gitignore scopes override the root beneath their directory',
        truth: GIT_TRUTH,
        rules: gitRules([
            { dir: '', lines: ['*.log'] },
            { dir: 'packages/app', lines: ['*.secret', '!keep.log'] },
        ]),
        cases: [
            { path: 'packages/app/db.secret', excluded: true },
            { path: 'db.secret', excluded: false },
            { path: 'packages/app/keep.log', excluded: false },
            { path: 'root.log', excluded: true },
        ],
    },
    {
        name: 'a backslash escapes a leading hash',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['\\#tag'] }]),
        cases: [
            { path: '#tag', excluded: true },
            { path: 'tag', excluded: false },
        ],
    },
    {
        name: '**/ prefixed paths match at any depth',
        truth: GIT_TRUTH,
        rules: gitRules([{ dir: '', lines: ['**/foo/bar'] }]),
        cases: [
            { path: 'foo/bar', excluded: true },
            { path: 'a/foo/bar', excluded: true },
            { path: 'bar/foo', excluded: false },
        ],
    },
];
// ANCHOR - Policy Decisions
// Verdicts pinned by this CLI's own contract, not by an external reference.
const POLICY_TRUTH = 'RemoteIgnorePolicy contract';
const POLICY_GROUPS = [
    {
        name: 'an empty .dockerignore leaves only the baseline',
        truth: POLICY_TRUTH,
        rules: dockerRules([]),
        cases: [
            { path: 'dist/app.js', excluded: false },
            { path: 'node_modules/pkg/i.js', excluded: true },
            { path: '.git/config', excluded: true },
            { path: 'src/app.ts', excluded: false },
        ],
    },
    {
        name: '!node_modules overrides the baseline in docker mode',
        truth: POLICY_TRUTH,
        rules: dockerRules(['!node_modules']),
        cases: [
            { path: 'node_modules/pkg/i.js', excluded: false },
            { path: '.git/config', excluded: true },
        ],
    },
    {
        name: '!node_modules overrides the baseline in git mode',
        truth: POLICY_TRUTH,
        rules: gitRules([{ dir: '', lines: ['!node_modules'] }]),
        cases: [
            { path: 'node_modules/pkg/i.js', excluded: false },
            { path: '.git/config', excluded: true },
        ],
    },
    {
        name: 'Dockerfile and .dockerignore survive a docker-mode whitelist',
        truth: POLICY_TRUTH,
        rules: dockerRules(['*']),
        cases: [
            { path: 'Dockerfile', excluded: false },
            { path: '.dockerignore', excluded: false },
            { path: 'README.md', excluded: true },
        ],
    },
    {
        name: 'Dockerfile survives a git-mode wildcard too',
        truth: POLICY_TRUTH,
        rules: gitRules([{ dir: '', lines: ['*'] }]),
        cases: [
            { path: 'Dockerfile', excluded: false },
            { path: 'src/app.ts', excluded: true },
        ],
    },
    {
        name: 'an explicit rule cannot exclude the build inputs',
        truth: POLICY_TRUTH,
        rules: dockerRules(['Dockerfile', '.dockerignore']),
        cases: [
            { path: 'Dockerfile', excluded: false },
            { path: '.dockerignore', excluded: false },
        ],
    },
    {
        name: 'no ignore files: only the baseline applies',
        truth: POLICY_TRUTH,
        rules: { kind: 'none' },
        cases: [
            { path: '.git/config', excluded: true },
            { path: 'web/node_modules/y.js', excluded: true },
            { path: 'src/app.ts', excluded: false },
            { path: '.env', excluded: false },
        ],
    },
];
// ANCHOR - Corpus
exports.CONFORMANCE_CORPUS = [...DOCKER_GROUPS, ...GIT_GROUPS, ...POLICY_GROUPS];
//# sourceMappingURL=ignore.corpus.js.map