@nyaitter/nap 0.0.0-stage → 0.2.0

package/lib/get.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseDeclaration } = require('./declaration');
+
+const ID_PATTERN = /^[0-9a-f]{64}$/;
+const MODULES_DIR = 'nap_modules';
+
+// 取り寄せの指定を分解する。版まで含む指定と、
+// ソースだけの指定の両方を受ける。
+// ソースだけの場合は ref が null になり、最新の正式版に解決する。
+function parseGetTarget(text) {
+    if (typeof text !== 'string' || !text.trim()) {
+        throw new Error(`指定が不正です: ${text}`);
+    }
+    const spec = text.trim();
+    const parts = spec.split('/');
+    if (parts.length === 3 && parts.every((part) => part.length > 0)) {
+        return { repo: `${parts[0]}/${parts[1]}`, ref: parts[2] };
+    }
+    if (parts.length === 2 && parts.every((part) => part.length > 0)) {
+        return { repo: spec, ref: null };
+    }
+    throw new Error(
+        `指定が不正です: ${spec}。「<所有者>/<リポジトリ>」または「<所有者>/<リポジトリ>/<版>」で指定してください`,
+    );
+}
+
+// ソースから、nap.json の依存関係に書く参照を導く。参照は「<組織ID>/<名前>」の形。
+function dependencyRefFor(repo) {
+    const parts = String(repo).split('/').filter((part) => part.length > 0);
+    if (parts.length !== 2) {
+        throw new Error(`依存関係の参照を導けません: ${repo}`);
+    }
+    return `${parts[0].toLowerCase()}/${parts[1].toLowerCase()}`;
+}
+
+function defaultOutDir(repo) {
+    const base = repo.split('/').pop();
+    return path.resolve(process.cwd(), base || 'nap-package');
+}
+
+function assertSafeRel(rel) {
+    const segments = rel.split('/');
+    if (path.isAbsolute(rel) || segments.includes('..') || segments.includes('')) {
+        throw new Error(`不正なファイルパスです: ${rel}`);
+    }
+}
+
+function writePackageFiles(dir, pkg) {
+    if (pkg.manifest) {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(
+            path.join(dir, 'version-manifest.json'),
+            `${JSON.stringify(pkg.manifest, null, 2)}\n`,
+        );
+    }
+    for (const [rel, bytes] of Object.entries(pkg.files || {})) {
+        assertSafeRel(rel);
+        const target = path.join(dir, rel);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, bytes);
+    }
+}
+
+function writeExtract(dir, pkg, label) {
+    writePackageFiles(dir, pkg);
+    console.log(`${label}: ${Object.keys(pkg.files || {}).length} 点 → ${dir}`);
+    for (const [ref, lib] of Object.entries(pkg.libraries || {})) {
+        writeExtract(path.join(dir, 'libraries', ref), lib, `構成員 ${ref}`);
+    }
+}
+
+// 導入先にパッケージを置く。そのパッケージの構成員は、同じ nap_modules の
+// 直下へ並べて置く。依存関係への記録は、直接導入したものだけが行う。
+function isForkDir(dir) {
+    return fs.existsSync(path.join(dir, '.git'));
+}
+
+// writeInstalled はフォーク済みの場所を上書きしない。
+function writeInstalled(modulesDir, ref, pkg) {
+    if (isForkDir(path.join(modulesDir, ref))) {
+        console.log(`フォーク済みのため、そのままにしました: ${ref}`);
+        return;
+    }
+    const dir = path.join(modulesDir, ref);
+    fs.rmSync(dir, { recursive: true, force: true });
+    writePackageFiles(dir, pkg);
+    for (const [libRef, lib] of Object.entries(pkg.libraries || {})) {
+        writeInstalled(modulesDir, libRef, lib);
+    }
+}
+
+// nap.json の依存関係 composition に、参照と版を記録した新しい宣言文を作る。
+// 記録の形は検証を通してから返す。呼び出し側は、設置が終わるまで書き込まない。
+function recordDependency(declarationText, ref, versionId) {
+    const doc = JSON.parse(declarationText);
+    const composition = Array.isArray(doc.composition) ? [...doc.composition] : [];
+    const entryName = (entry) => (typeof entry === 'string' ? entry : entry && entry.name);
+    const index = composition.findIndex((entry) => entryName(entry) === ref);
+    const record = { name: ref, version: versionId };
+    if (index >= 0) composition[index] = record;
+    else composition.push(record);
+    doc.composition = composition;
+    const text = `${JSON.stringify(doc, null, 2)}\n`;
+    parseDeclaration(text);
+    return text;
+}
+
+// 実行ディレクトリの nap.json に記録された依存関係を、すべて導入する。
+// 取得先のソースは、参照から導いたものを使う。参照は「<組織ID>/<名前>」の形。
+async function installAll() {
+    const cwd = process.cwd();
+    const declarationPath = path.join(cwd, 'nap.json');
+    if (!fs.existsSync(declarationPath)) {
+        throw new Error(
+            'nap.json がありません。依存の一括導入は、プロジェクトのフォルダで実行してください。',
+        );
+    }
+    const declarationText = fs.readFileSync(declarationPath, 'utf8');
+    const declaration = parseDeclaration(declarationText);
+    if (!declaration.composition || declaration.composition.length === 0) {
+        console.log('依存関係は記録されていません。');
+        return;
+    }
+    const { createClient } = await import('../client/nap-client.js');
+    const client = createClient({ rawBase: process.env.NAP_RAW_BASE || undefined });
+    let text = declarationText;
+    for (const member of declaration.composition) {
+        if (isForkDir(path.join(cwd, MODULES_DIR, member.ref))) {
+            console.log(`フォーク済みのため、そのままにしました: ${member.ref}`);
+            continue;
+        }
+        let ref = member.version;
+        if (!ref) {
+            const latest = await client.latestVersion(member.ref);
+            if (!latest) {
+                throw new Error(`正式版はまだありません: ${member.ref}`);
+            }
+            ref = latest.id;
+        }
+        const result = await client.fetchVersion(member.ref, ref);
+        writeInstalled(path.join(cwd, MODULES_DIR), member.ref, result);
+        text = recordDependency(text, member.ref, result.versionId);
+        console.log(`導入: ${member.ref} = ${result.versionId}`);
+    }
+    fs.writeFileSync(declarationPath, text);
+    console.log('依存関係をすべて導入しました。');
+}
+
+async function get(specText, options = {}) {
+    if (specText === undefined || specText === null) {
+        if (options.out) {
+            throw new Error('一括導入では --out は使えません。');
+        }
+        return installAll();
+    }
+    const { repo, ref } = parseGetTarget(specText);
+    const { createClient } = await import('../client/nap-client.js');
+    const client = createClient({ rawBase: process.env.NAP_RAW_BASE || undefined });
+
+    let targetRef = ref;
+    if (!targetRef) {
+        const latest = await client.latestVersion(repo);
+        if (!latest) {
+            throw new Error(`正式版はまだありません: ${repo}`);
+        }
+        targetRef = latest.id;
+    }
+    const result = await client.fetchVersion(repo, targetRef);
+
+    // 実行ディレクトリに nap.json があり、出力先の明示が無い場合は「導入」になる。
+    const cwd = process.cwd();
+    const declarationPath = path.join(cwd, 'nap.json');
+    if (!options.out && fs.existsSync(declarationPath)) {
+        const depRef = dependencyRefFor(repo);
+        const modulesDir = path.join(cwd, MODULES_DIR);
+        if (isForkDir(path.join(modulesDir, depRef))) {
+            console.log(
+                `版ID: ${result.versionId}${result.tag ? ` / 開発中の版: ${result.tag}` : ''}`,
+            );
+            console.log(`フォーク済みのため、そのままにしました: ${depRef}`);
+            return;
+        }
+        const declarationText = fs.readFileSync(declarationPath, 'utf8');
+        parseDeclaration(declarationText);
+        const updated = recordDependency(declarationText, depRef, result.versionId);
+        writeInstalled(modulesDir, depRef, result);
+        fs.writeFileSync(declarationPath, updated);
+        console.log(`版ID: ${result.versionId}${result.tag ? ` / 開発中の版: ${result.tag}` : ''}`);
+        console.log(`導入: ${depRef} → ${path.join(modulesDir, depRef)}`);
+        console.log(`依存関係に記録しました: ${depRef} = ${result.versionId}`);
+        return;
+    }
+
+    const outDir = options.out ? path.resolve(options.out) : defaultOutDir(repo);
+    if (fs.existsSync(outDir) && fs.readdirSync(outDir).length > 0) {
+        throw new Error(`出力先が空ではありません: ${outDir}`);
+    }
+    fs.mkdirSync(outDir, { recursive: true });
+    console.log(`版ID: ${result.versionId}${result.tag ? ` / 開発中の版: ${result.tag}` : ''}`);
+    writeExtract(outDir, result, '本体');
+    console.log(
+        `取得: ${result.stats.fetched} 件 / キャッシュ: ${result.stats.cached} 件`,
+    );
+}
+
+module.exports = { get, installAll, parseGetTarget, dependencyRefFor, recordDependency, isForkDir, MODULES_DIR };

package/lib/git.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+const MAX_BUFFER = 512 * 1024 * 1024;
+
+// git を実行して標準出力を Buffer で返す。失敗したら例外。
+function git(args, { cwd, env, input } = {}) {
+    return execFileSync('git', args, {
+        cwd,
+        env: { ...process.env, ...(env || {}) },
+        input,
+        maxBuffer: MAX_BUFFER,
+    });
+}
+
+function gitText(args, opts) {
+    return git(args, opts).toString('utf8').trim();
+}
+
+function refExists(root, ref) {
+    try {
+        gitText(['rev-parse', '--verify', '--quiet', ref], { cwd: root });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+// リモート名から URL を引く。引けない場合は指定そのものを URL／パスとして扱う。
+function remoteUrl(root, remote) {
+    try {
+        return gitText(['remote', 'get-url', remote], { cwd: root });
+    } catch {
+        return remote;
+    }
+}
+
+module.exports = { git, gitText, refExists, remoteUrl };

package/lib/glob.js

@@ -0,0 +1,59 @@
+'use strict';
+
+function escapeRegExpChar(ch) {
+    return /[.+^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+}
+
+function patternToRegExp(pattern) {
+    let source = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                if (pattern[i + 2] === '/') {
+                    source += '(?:.*/)?';
+                    i += 3;
+                } else {
+                    source += '.*';
+                    i += 2;
+                }
+            } else {
+                source += '[^/]*';
+                i += 1;
+            }
+        } else if (ch === '?') {
+            source += '[^/]';
+            i += 1;
+        } else {
+            source += escapeRegExpChar(ch);
+            i += 1;
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+
+function compilePattern(pattern) {
+    const regex = patternToRegExp(pattern);
+    const hasGlob = /[*?]/.test(pattern);
+    return (relPath) => {
+        if (regex.test(relPath)) return true;
+        // ワイルドカードのない指定がフォルダを指す場合は、その中身すべてが対象になる。
+        return !hasGlob && relPath.startsWith(`${pattern}/`);
+    };
+}
+
+function createMatcher(patterns) {
+    const includes = [];
+    const excludes = [];
+    for (const raw of patterns) {
+        if (raw.startsWith('!')) excludes.push(compilePattern(raw.slice(1)));
+        else includes.push(compilePattern(raw));
+    }
+    return (relPath) => {
+        if (!includes.some((test) => test(relPath))) return false;
+        return !excludes.some((test) => test(relPath));
+    };
+}
+
+module.exports = { createMatcher };

package/lib/init.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { git, gitText } = require('./git');
+const { DECLARATION_FILE, NAME_PATTERN } = require('./declaration');
+
+// origin の URL からリポジトリ名を引き出す。
+function nameFromRemote(root) {
+    let url;
+    try {
+        url = gitText(['remote', 'get-url', 'origin'], { cwd: root });
+    } catch {
+        return null;
+    }
+    const cleaned = url.replace(/\.git$/, '').replace(/[/:]$/, '');
+    const segment = cleaned.split(/[/:]/).pop();
+    return segment || null;
+}
+
+// カレントディレクトリに宣言 nap.json を作る。
+async function init(nameArg) {
+    const root = process.cwd();
+    const file = path.join(root, DECLARATION_FILE);
+    if (fs.existsSync(file)) {
+        throw new Error(`${DECLARATION_FILE} は既にあります。`);
+    }
+    let inRepo = true;
+    try {
+        git(['rev-parse', '--git-dir'], { cwd: root });
+    } catch {
+        inRepo = false;
+    }
+    const name = (
+        nameArg ||
+        (inRepo ? nameFromRemote(root) : null) ||
+        path.basename(root)
+    ).toLowerCase();
+    if (!NAME_PATTERN.test(name)) {
+        throw new Error(
+            `パッケージ名が不正です: ${name}。小文字の英数字と . _ - で書いてください。引数で名前を指定できます`,
+        );
+    }
+    const doc = { name, include: ['**'] };
+    fs.writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`, 'utf8');
+    console.log(`${DECLARATION_FILE} を作りました。パッケージ名: ${name}`);
+    console.log('include はパッケージに含めるファイルのパターンです。必要に応じて編集してください。');
+    if (!inRepo) {
+        console.log('このフォルダは Git リポジトリではありません。発行には Git リポジトリが必要です。');
+    }
+}
+
+module.exports = { init };

package/lib/inspect.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const path = require('path');
+const { git, gitText } = require('./git');
+const {
+    MANIFEST_NAME,
+    INDEX_BRANCH,
+    versionIdOf,
+    parseManifest,
+    parseVersionRef,
+    tagRefFor,
+    isVersionCode,
+} = require('./core');
+const { readIndexAt, openSnapshot, listTagIds } = require('./read');
+const { resolveRepoRoot } = require('./publish');
+
+async function list(repoSpec, options = {}) {
+    const root = resolveRepoRoot(repoSpec);
+    const snapshot = openSnapshot(root, options.remote || 'origin');
+    const { head, entries } = readIndexAt(snapshot, `refs/heads/${INDEX_BRANCH}`);
+    if (entries.length === 0) {
+        console.log('版はまだありません。');
+        return;
+    }
+    console.log(`版の総数: ${head.total} / 表示: ${entries.length} 件`);
+    let latestFormal = -1;
+    entries.forEach((entry, index) => {
+        if (!entry.tag) latestFormal = index;
+    });
+    entries.forEach((entry, index) => {
+        const marks = [];
+        if (entry.tag) marks.push(`開発中: ${entry.tag}`);
+        if (index === latestFormal) marks.push('最新');
+        const display = entry.tag ? `${entry.id}-${entry.tag}` : entry.id;
+        const code = entry.code ? ` code=${entry.code}` : '';
+        console.log(
+            `  ${entry.id.slice(0, 12)} ${display}${code} commit=${entry.commit.slice(0, 12)} at=${entry.at}${marks.length ? ` / ${marks.join('、')}` : ''}`,
+        );
+    });
+}
+
+// 「<版ID>」または「<版ID>-<ラベル>」の指定を、タグの一覧から一意に解決する。
+// ラベルなしの指定は正式版だけを対象にする。
+function resolveVersionRef(snapshot, refText) {
+    const { prefix, tag } = parseVersionRef(refText);
+    const matches = listTagIds(snapshot)
+        .map((suffix) => {
+            try {
+                const parsed = parseVersionRef(suffix);
+                return { id: parsed.prefix, tag: parsed.tag };
+            } catch {
+                return null;
+            }
+        })
+        .filter((candidate) => candidate && candidate.id.startsWith(prefix) && candidate.tag === tag);
+    if (matches.length === 0) throw new Error(`版が見つかりません: ${refText}`);
+    if (matches.length > 1) throw new Error(`版が一意に決まりません: ${refText}`);
+    return matches[0];
+}
+
+async function show(versionRefText, options = {}) {
+    const root = resolveRepoRoot(options.repo);
+    const snapshot = openSnapshot(root, options.remote || 'origin');
+    let resolved;
+    if (versionRefText) {
+        // 版コードは索引から引く。版IDの省略形より優先する。
+        let byCode = null;
+        if (isVersionCode(versionRefText)) {
+            const { entries: codeEntries } = readIndexAt(snapshot, `refs/heads/${INDEX_BRANCH}`);
+            const hit = codeEntries.find((entry) => entry.code === versionRefText);
+            if (hit) byCode = { id: hit.id, tag: hit.tag || null };
+        }
+        resolved = byCode || resolveVersionRef(snapshot, versionRefText);
+    } else {
+        // 版の指定が無ければ、最新の正式版を指す。TestVersion は勝手に選ばない。
+        const { entries } = readIndexAt(snapshot, `refs/heads/${INDEX_BRANCH}`);
+        if (entries.length === 0) throw new Error('版はまだありません。');
+        const formal = entries.filter((entry) => !entry.tag);
+        if (formal.length === 0) {
+            throw new Error('正式版はまだありません。開発中の版だけが発行されています。');
+        }
+        resolved = { id: formal[formal.length - 1].id, tag: null };
+    }
+    const { id, tag } = resolved;
+    const commit = gitText(
+        ['--git-dir', snapshot, 'rev-parse', `refs/tags/${tagRefFor(id, tag)}`],
+        {},
+    );
+    let manifest;
+    try {
+        manifest = parseManifest(
+            git(['--git-dir', snapshot, 'cat-file', 'blob', `${commit}:${MANIFEST_NAME}`], {}),
+        );
+    } catch (error) {
+        throw new Error(`マニフェストを読めません: ${error.message}`);
+    }
+    const recomputed = versionIdOf(manifest.files, manifest.libraries);
+    console.log(`版ID: ${id}`);
+    if (tag) console.log(`ラベル: ${tag}。開発中の版`);
+    console.log(`再計算: ${recomputed === id ? '一致' : `不一致: ${recomputed}`}`);
+    const { entries: showEntries } = readIndexAt(snapshot, `refs/heads/${INDEX_BRANCH}`);
+    const shown = showEntries.find((e) => e.id === id && (e.tag || null) === (tag || null));
+    if (shown && shown.source) console.log(`出典コミット: ${shown.source}`);
+    if (shown && shown.code) console.log(`版コード: ${shown.code}`);
+    const description = gitText(['--git-dir', snapshot, 'log', '-1', '--format=%b', commit], {});
+    if (description) console.log(`説明: ${description}`);
+    console.log(`ファイル: ${Object.keys(manifest.files).length} 点`);
+    for (const rel of Object.keys(manifest.files)) {
+        console.log(`  ${rel} ${manifest.files[rel].slice(0, 12)}`);
+    }
+    const refs = Object.keys(manifest.libraries);
+    console.log(`構成員: ${refs.length} 件`);
+    for (const ref of refs) {
+        const lib = manifest.libraries[ref];
+        console.log(`  ${ref} repo=${lib.repo} version=${lib.version}`);
+    }
+    return { id, tag, manifest };
+}
+
+module.exports = { list, show };