@rigour-labs/core 6.7.10 → 6.8.1-rc.1

package/dist/utils/glob-paths.test.js

@@ -1,40 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { FileScanner } from './scanner.js';
-import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
-let root;
-beforeEach(() => {
-    root = fs.mkdtempSync(path.join(os.tmpdir(), 'glob-paths-'));
-    fs.mkdirSync(path.join(root, 'src'));
-    fs.mkdirSync(path.join(root, 'legacy'));
-    fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n');
-    fs.writeFileSync(path.join(root, 'legacy', 'old.ts'), 'export const b = 2;\n');
-});
-afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
-describe('withDirectoryForms', () => {
-    it('adds the directory form to plain paths and leaves globs alone', () => {
-        expect(withDirectoryForms(['legacy', 'build/', '.git/**', '**/*.min.js'])).toEqual(['legacy', 'legacy/**', 'build/', 'build/**', '.git/**', '**/*.min.js']);
-    });
-});
-describe('directoriesAsGlobs', () => {
-    it('turns a directory into dir/** and leaves files, missing paths and globs alone', () => {
-        expect(directoriesAsGlobs(root, ['src', 'src/a.ts', 'missing', '**/*.ts'])).toEqual(['src/**', 'src/a.ts', 'missing', '**/*.ts']);
-    });
-});
-describe('FileScanner in a git worktree', () => {
-    it('scans when .git is a file and the config ignores .git/**', async () => {
-        fs.writeFileSync(path.join(root, '.git'), 'gitdir: /elsewhere/.git/worktrees/x\n');
-        const files = await FileScanner.findFiles({ cwd: root, patterns: ['**/*.ts'], ignore: ['.git/**'] });
-        expect(files.sort()).toEqual(['legacy/old.ts', 'src/a.ts']);
-    });
-    it('finds a file or a whole directory named by a plain path', async () => {
-        expect(await FileScanner.findFiles({ cwd: root, patterns: ['src/a.ts'] })).toEqual(['src/a.ts']);
-        expect(await FileScanner.findFiles({ cwd: root, patterns: ['legacy'] })).toEqual(['legacy/old.ts']);
-    });
-    it('still ignores a whole directory named by a plain path', async () => {
-        const files = await FileScanner.findFiles({ cwd: root, patterns: ['**/*.ts'], ignore: ['legacy'] });
-        expect(files).toEqual(['src/a.ts']);
-    });
-});

package/dist/utils/profile.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/profile.test.js

@@ -1,68 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { applyProfile, hostPath, profileFor, profileMismatch } from './profile.js';
-let root;
-const saved = { ...process.env };
-const repo = (rel, remote) => {
-    const dir = path.join(root, rel);
-    fs.mkdirSync(dir, { recursive: true });
-    execFileSync('git', ['init', '-q'], { cwd: dir });
-    if (remote)
-        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: dir });
-    return dir;
-};
-beforeEach(() => { root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'profiles-'))); });
-afterEach(() => { process.env = { ...saved }; fs.rmSync(root, { recursive: true, force: true }); });
-describe('profiles', () => {
-    it('matches a repository by path prefix or by origin remote, first match winning', () => {
-        const byPath = repo('work/acme/api');
-        const byRemote = repo('elsewhere/web', 'git@github.com:Acme/web.git');
-        const other = repo('personal/tool', 'https://github.com/me/tool');
-        const profiles = [
-            { name: 'acme-path', match: [path.join(root, 'work/acme')] },
-            { name: 'acme-remote', match: ['github.com/acme/*'] },
-        ];
-        expect(profileFor(path.join(byPath, 'src'), profiles)?.name).toBe('acme-path');
-        expect(profileFor(byRemote, profiles)?.name).toBe('acme-remote');
-        expect(profileFor(other, profiles)).toBeUndefined();
-        expect(profileFor(path.join(root, 'work/acme-evil'), profiles)).toBeUndefined();
-        expect(hostPath('https://GitHub.com/Acme/web.git/')).toBe('github.com/acme/web');
-    });
-    it("applies the profile's home and team, clearing team settings inherited from the shell", () => {
-        const dir = repo('work/acme/api');
-        delete process.env.RIGOUR_HOME; // no home of your own: the profile chooses it
-        process.env.RIGOUR_TEAM_DATABASE_URL = 'postgres://other-org';
-        process.env.RIGOUR_ORGANIZATION_ID = 'other-org';
-        applyProfile(dir, [{ name: 'acme', match: [path.join(root, 'work/acme')], home: path.join(root, 'acme-home'), githubAccount: 'acme-dev' }]);
-        expect(process.env.RIGOUR_HOME).toBe(path.join(root, 'acme-home'));
-        expect(process.env.RIGOUR_PROFILE).toBe('acme');
-        expect(process.env.RIGOUR_GITHUB_ACCOUNT).toBe('acme-dev');
-        expect(process.env.RIGOUR_TEAM_DATABASE_URL).toBeUndefined();
-        expect(process.env.RIGOUR_ORGANIZATION_ID).toBeUndefined();
-        applyProfile(dir, [{ name: 'acme', match: [dir], team: { organization: 'acme', team: 'web', actor: 'dev', repositories: ['github.com/acme/*'], databaseUrlCommand: 'echo url' } }]);
-        expect([process.env.RIGOUR_ORGANIZATION_ID, process.env.RIGOUR_TEAM_REPOSITORIES, process.env.RIGOUR_TEAM_DATABASE_URL_COMMAND]).toEqual(['acme', 'github.com/acme/*', 'echo url']);
-    });
-    it('leaves a RIGOUR_HOME you set yourself alone: no profile replaces it or brings its team', () => {
-        const dir = repo('work/acme/api');
-        delete process.env.RIGOUR_PROFILE;
-        process.env.RIGOUR_HOME = path.join(root, 'isolated');
-        const applied = applyProfile(dir, [{ name: 'acme', match: [path.join(root, 'work/acme')], home: path.join(root, 'acme-home'), team: { organization: 'acme', team: 'web', actor: 'dev' } }]);
-        expect(applied).toBeUndefined();
-        expect(process.env.RIGOUR_HOME).toBe(path.join(root, 'isolated'));
-        expect(process.env.RIGOUR_ORGANIZATION_ID).toBeUndefined();
-    });
-    it('refuses to act for a repository of another profile than the one the process started with', () => {
-        const acme = repo('work/acme/api');
-        const mine = repo('personal/tool');
-        const profiles = [{ name: 'acme', match: [path.join(root, 'work/acme')] }];
-        delete process.env.RIGOUR_PROFILE;
-        expect(profileMismatch(mine, profiles)).toBeNull();
-        expect(profileMismatch(acme, profiles)).toContain('belongs to the Rigour profile "acme"');
-        process.env.RIGOUR_PROFILE = 'acme';
-        expect(profileMismatch(acme, profiles)).toBeNull();
-        expect(profileMismatch(mine, profiles)).toContain('started as "acme"');
-    });
-});

package/dist/utils/scanner.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/scanner.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { FileScanner } from './scanner.js';
-import { globby } from 'globby';
-vi.mock('globby', async (importOriginal) => ({
-    isDynamicPattern: (await importOriginal()).isDynamicPattern,
-    globby: vi.fn(async () => []),
-}));
-describe('FileScanner', () => {
-    it('returns files in a fixed order, whatever order the walk found them in', async () => {
-        vi.mocked(globby).mockResolvedValueOnce(['src/z.ts', 'scripts/a.ts', 'src/a.ts']);
-        expect(await FileScanner.findFiles({ cwd: '/test' })).toEqual(['scripts/a.ts', 'src/a.ts', 'src/z.ts']);
-    });
-    it('should merge default ignores with user ignores', async () => {
-        const options = {
-            cwd: '/test',
-            ignore: ['custom-ignore']
-        };
-        await FileScanner.findFiles(options);
-        const call = vi.mocked(globby).mock.calls.at(-1);
-        const ignore = call[1].ignore;
-        expect(ignore).toContain('**/node_modules/**');
-        expect(ignore).toContain('custom-ignore');
-    });
-    it('should normalize Windows paths to forward slashes', async () => {
-        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
-        Object.defineProperty(process, 'platform', { value: 'win32' });
-        try {
-            await FileScanner.findFiles({ cwd: 'C:\\test\\path', patterns: ['**\\*.ts', 'app\\\\[key\\]\\route.ts'] });
-        }
-        finally {
-            Object.defineProperty(process, 'platform', platform);
-        }
-        const call = vi.mocked(globby).mock.calls.at(-1);
-        expect(call[0]).toEqual(['**/*.ts', 'app/\\[key\\]/route.ts']);
-        expect(call[1]?.cwd).toBe('C:/test/path');
-    });
-    it('should keep glob escapes on POSIX', async () => {
-        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
-        Object.defineProperty(process, 'platform', { value: 'linux' });
-        try {
-            await FileScanner.findFiles({ cwd: '/repo', patterns: ['src/app/\\[key\\]/route.ts'] });
-        }
-        finally {
-            Object.defineProperty(process, 'platform', platform);
-        }
-        expect(vi.mocked(globby).mock.calls.at(-1)[0]).toEqual(['src/app/\\[key\\]/route.ts']);
-    });
-});

package/dist/utils/scope.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/scope.test.js

@@ -1,38 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { isScoped, normalizeScopePatterns, resolveScopedFiles, touchesScope } from './scope.js';
-describe('scope', () => {
-    let cwd;
-    beforeEach(async () => {
-        cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scope-'));
-        await fs.outputFile(path.join(cwd, 'src/app/[key]/route.ts'), 'export {}');
-        await fs.outputFile(path.join(cwd, 'src/app/k/route.ts'), 'export {}');
-        await fs.outputFile(path.join(cwd, 'src/lib/a.ts'), 'export {}');
-    });
-    afterEach(async () => { await fs.remove(cwd); });
-    it('turns absolute, relative and directory inputs into cwd-relative patterns', async () => {
-        const patterns = await normalizeScopePatterns(cwd, [path.join(cwd, 'src/lib/a.ts'), './src/lib', 'src/lib/a.ts']);
-        expect(patterns).toEqual(['src/lib/a.ts', 'src/lib/**/*', 'src/lib/a.ts']);
-    });
-    it('escapes glob characters so a Next.js [key] route matches only itself', async () => {
-        const patterns = await normalizeScopePatterns(cwd, ['src/app/[key]/route.ts']);
-        expect([...await resolveScopedFiles(cwd, patterns)]).toEqual(['src/app/[key]/route.ts']);
-    });
-    it('keeps a non-existent input as the glob the user wrote', async () => {
-        expect(await normalizeScopePatterns(cwd, ['src/**/*.ts'])).toEqual(['src/**/*.ts']);
-    });
-    it('treats the repo root as everything', async () => {
-        expect(await normalizeScopePatterns(cwd, ['.'])).toEqual(['**/*']);
-    });
-    it('detects scoped runs and scope membership', () => {
-        expect(isScoped(undefined)).toBe(false);
-        expect(isScoped([])).toBe(false);
-        expect(isScoped(['a.ts'])).toBe(true);
-        const scoped = new Set(['src/lib/a.ts']);
-        expect(touchesScope(['./src/lib/a.ts', 'b.ts'], scoped)).toBe(true);
-        expect(touchesScope(['b.ts'], scoped)).toBe(false);
-        expect(touchesScope(undefined, scoped)).toBe(false);
-    });
-});