@dominic.mayers/last-of-readme 0.1.21 → 0.1.22

package/README.md

@@ -1,6 +1,6 @@
 # Last of README
 
-[![npm version](https://img.shields.io/npm/v/@dominic.mayers/last-of-readme)](https://www.npmjs.com/package/@dominic.mayers/last-of-readme) <!-- DOC-LINK-START --><a href="https://dominic-mayers.github.io/last-of-readme/readme-resolver.html?mode=last&pkg=%40dominic.mayers%2Flast-of-readme&repo=Dominic-Mayers%2Flast-of-readme&host=github.com&v=0.1.21&urlPath="><img alt="README-last of 0.1.21" src="https://img.shields.io/badge/README-last%20of%200.1.21-blue?logo=github"></a><!-- DOC-LINK-END -->
+[![npm version](https://img.shields.io/npm/v/@dominic.mayers/last-of-readme)](https://www.npmjs.com/package/@dominic.mayers/last-of-readme) <!-- DOC-LINK-START --><a href="https://dominic-mayers.github.io/last-of-readme/readme-resolver.html?mode=last&pkg=%40dominic.mayers%2Flast-of-readme&repo=Dominic-Mayers%2Flast-of-readme&host=github.com&v=0.1.22&urlPath="><img alt="README-last of 0.1.22" src="https://img.shields.io/badge/README-last%20of%200.1.22-blue?logo=github"></a><!-- DOC-LINK-END -->
 
 By default, a package version is expected to contain its correct documentation, but in practice there is no guarantee that documentation is complete or even correct at release time.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dominic.mayers/last-of-readme",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Resolve README to last relevant commit based on npm version",
   "author": "Dominic Mayers",
   "license": "MIT",
@@ -25,6 +25,8 @@
       "kind": "github",
       "host": "github.com",
       "repository": "Dominic-Mayers/last-of-readme"
-    }
+    },
+    "packageFilePath": "README.md",
+    "repositoryUrlPath": ""
   }
 }

package/scripts/collect-user-input.cjs

@@ -1,22 +1,65 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
-const path = require('path');
+const { execFileSync } = require('child_process');
 const readline = require('readline');
 const { listRemoteChoices } = require('./install-remote.cjs');
 
-function loadPackageJson() {
-  const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-  if (!fs.existsSync(packageJsonPath)) {
-    return null;
+function runNpmPkg(args, { allowFailure = false } = {}) {
+  try {
+    return execFileSync('npm', ['pkg', ...args], {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+  } catch (error) {
+    if (allowFailure) {
+      return null;
+    }
+
+    const stderr = String(error.stderr || '').trim();
+    const suffix = stderr ? `: ${stderr}` : '';
+    throw new Error(`Could not access package.json through npm pkg${suffix}`);
   }
+}
 
+function getPackageJsonField(fieldPath) {
+  const raw = runNpmPkg(['get', fieldPath, '--json'], { allowFailure: true });
+  if (raw === null || raw === '') {
+    return undefined;
+  }
+
+  let parsed;
   try {
-    const raw = fs.readFileSync(packageJsonPath, 'utf8');
-    return JSON.parse(raw);
+    parsed = JSON.parse(raw);
   } catch (error) {
-    throw new Error(`Could not read package.json: ${error.message}`);
+    throw new Error(`Could not parse npm pkg output for ${fieldPath}: ${error.message}`);
+  }
+
+  return getNestedValue(parsed, fieldPath);
+}
+
+function getNestedValue(value, fieldPath) {
+  return fieldPath
+    .split('.')
+    .reduce(
+      (current, key) =>
+        current && typeof current === 'object' && key in current ? current[key] : undefined,
+      value
+    );
+}
+
+function loadPackageJson() {
+  const versionScript = getPackageJsonField('scripts.version');
+
+  if (typeof versionScript === 'undefined') {
+    return null;
   }
+
+  return {
+    scripts: {
+      version: versionScript,
+    },
+  };
 }
 
 function parsePackageFilePathFromVersionScript(versionScript) {
@@ -28,7 +71,7 @@ function parsePackageFilePathFromVersionScript(versionScript) {
     /node\s+scripts\/update-readme-link\.cjs\s+(?:'([^']+)'|"([^"]+)"|([^\s]+))/
   );
 
-  return match ? (match[1] || match[2] || match[3]) : null;
+  return match ? match[1] || match[2] || match[3] : null;
 }
 
 function parseRepositoryUrlPathFromVersionScript(versionScript) {
@@ -40,7 +83,7 @@ function parseRepositoryUrlPathFromVersionScript(versionScript) {
     /node\s+scripts\/update-readme-link\.cjs\s+(?:'[^']+'|"[^"]+"|[^\s]+)\s+(?:'([^']*)'|"([^"]*)"|([^\s]+))/
   );
 
-  return match ? (match[1] || match[2] || match[3] || '') : null;
+  return match ? match[1] || match[2] || match[3] || '' : null;
 }
 
 function createInterface() {
@@ -232,4 +275,6 @@ module.exports = {
   loadPackageJson,
   parsePackageFilePathFromVersionScript,
   parseRepositoryUrlPathFromVersionScript,
+  runNpmPkg,
+  getPackageJsonField,
 };

package/scripts/install-doc-link.cjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 
 const START_MARKER = '<!-- DOC-LINK-START -->';
 const END_MARKER = '<!-- DOC-LINK-END -->';
@@ -188,67 +188,41 @@ function installDocLink(config = {}) {
   };
 }
 
-function runNpmPkg(args, errorPrefix) {
-  try {
-    return execFileSync('npm', ['pkg', ...args], {
-      cwd: process.cwd(),
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }).trim();
-  } catch (error) {
-    const details = [error.stderr, error.stdout]
-      .filter(Boolean)
-      .map((value) => String(value).trim())
-      .find(Boolean);
+function runNpmPkg(args, failureMessage) {
+  const result = spawnSync('npm', ['pkg', ...args], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+  });
 
-    throw new Error(
-      details ? `${errorPrefix}: ${details}` : `${errorPrefix}: ${error.message}`
-    );
+  if (result.error) {
+    throw new Error(`${failureMessage}: ${result.error.message}`);
   }
-}
-
-function readPackageJson() {
-  const raw = runNpmPkg(['get', '--json'], 'Could not read package.json');
 
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`Could not parse package.json content from npm pkg get: ${error.message}`);
+  if (result.status !== 0) {
+    const suffix = (result.stderr || result.stdout || '').trim();
+    throw new Error(`${failureMessage}${suffix ? `: ${suffix}` : ''}`);
   }
+
+  return (result.stdout || '').trim();
 }
 
 function getPackageJsonField(field) {
   const raw = runNpmPkg(['get', field, '--json'], `Could not read package.json field "${field}"`);
 
-  if (!raw || raw === 'undefined') {
-    return undefined;
-  }
-
-  let parsed;
   try {
-    parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
   } catch (error) {
     throw new Error(
       `Could not parse package.json field "${field}" from npm pkg get: ${error.message}`
     );
   }
-
-  if (
-    parsed &&
-    typeof parsed === 'object' &&
-    !Array.isArray(parsed) &&
-    Object.prototype.hasOwnProperty.call(parsed, field)
-  ) {
-    return parsed[field];
-  }
-
-  return parsed;
 }
 
-function setPackageJsonFields(updates) {
-  const assignments = Object.entries(updates).map(
-    ([key, value]) => `${key}=${JSON.stringify(value)}`
-  );
+function setPackageJsonFields(assignments) {
+  if (!Array.isArray(assignments) || assignments.length === 0) {
+    return;
+  }
 
   runNpmPkg(['set', '--json', ...assignments], 'Could not update package.json');
 }
@@ -274,20 +248,20 @@ function installDocLinkPackageJson(config = {}) {
     throw new Error('Doc-link package.json installation requires resolved doc-link cycle state');
   }
 
-  const updates = {
-    'scripts.version': buildVersionScript(
-      docLink.packageFilePath,
-      docLink.repositoryUrlPath
-    ),
-  };
+  const assignments = [
+    `lastOfReadme.packageFilePath=${JSON.stringify(docLink.packageFilePath)}`,
+    `lastOfReadme.repositoryUrlPath=${JSON.stringify(docLink.repositoryUrlPath || '')}`,
+    `scripts.version=${JSON.stringify(
+      buildVersionScript(docLink.packageFilePath, docLink.repositoryUrlPath)
+    )}`,
+  ];
 
-  const files = getPackageJsonField('files');
-  if (files !== undefined) {
-    if (!Array.isArray(files)) {
-      throw new Error('package.json.files must be an array when present');
-    }
+  setPackageJsonFields(assignments);
 
+  const files = getPackageJsonField('files');
+  if (Array.isArray(files)) {
     const nextFiles = [...files];
+
     if (!nextFiles.includes(docLink.packageFilePath)) {
       nextFiles.push(docLink.packageFilePath);
     }
@@ -297,16 +271,15 @@ function installDocLinkPackageJson(config = {}) {
       docLink.previousPackageFilePath &&
       docLink.previousPackageFilePath !== docLink.packageFilePath
     ) {
-      updates.files = nextFiles.filter(
+      const filteredFiles = nextFiles.filter(
         (item) => item !== docLink.previousPackageFilePath
       );
-    } else {
-      updates.files = nextFiles;
+      setPackageJsonFields([`files=${JSON.stringify(filteredFiles)}`]);
+    } else if (nextFiles.length !== files.length) {
+      setPackageJsonFields([`files=${JSON.stringify(nextFiles)}`]);
     }
   }
 
-  setPackageJsonFields(updates);
-
   return {
     path: 'package.json',
     packageFilePath: docLink.packageFilePath,
@@ -325,6 +298,6 @@ module.exports = {
   installDocLink,
   checkDocLinkPackageJsonRequirements,
   installDocLinkPackageJson,
-  readPackageJson,
+  getPackageJsonField,
   buildVersionScript,
 };

package/scripts/local-workspace-adapter.cjs

@@ -21,6 +21,44 @@ function run(command, options = {}) {
   }).trim();
 }
 
+function runNpmPkg(args) {
+  const result = cp.spawnSync('npm', ['pkg', ...args], {
+    cwd: WORKSPACE_ROOT,
+    encoding: 'utf8',
+  });
+
+  if (result.error) {
+    fail(`Could not run npm pkg ${args.join(' ')}: ${result.error.message}`);
+  }
+
+  if (result.status !== 0) {
+    const detail = (result.stderr || result.stdout || '').trim();
+    fail(`npm pkg ${args.join(' ')} failed${detail ? `: ${detail}` : ''}`);
+  }
+
+  const stdout = (result.stdout || '').trim();
+  if (!stdout) {
+    fail(`npm pkg ${args.join(' ')} returned no output`);
+  }
+
+  try {
+    return JSON.parse(stdout);
+  } catch (err) {
+    fail(`Could not parse npm pkg ${args.join(' ')} output: ${err.message}`);
+  }
+}
+
+function getPackageJsonField(field, { allowEmpty = false } = {}) {
+  const value = runNpmPkg(['get', field, '--json']);
+  const normalized = Array.isArray(value) && value.length === 1 ? value[0] : value;
+
+  if ((normalized === undefined || normalized === null || normalized === '') && !allowEmpty) {
+    fail(`package.json has no ${field}`);
+  }
+
+  return normalized;
+}
+
 function resolveWorkspacePath(relativePath) {
   if (!relativePath) {
     fail('Path is required');
@@ -37,7 +75,8 @@ function ensureFile(filePath, label) {
 function readPackageJson() {
   ensureFile(PACKAGE_PATH, 'package.json');
   try {
-    return JSON.parse(fs.readFileSync(PACKAGE_PATH, 'utf8'));
+    const result = runNpmPkg(['get', '--json']);
+    return Array.isArray(result) && result.length === 1 ? result[0] : result;
   } catch (err) {
     fail(`Could not read package.json: ${err.message}`);
   }
@@ -97,45 +136,37 @@ function currentRepoNode() {
 }
 
 function currentPackageVersion() {
-  const pkg = readPackageJson();
-  if (!pkg.version) {
-    fail('package.json has no version');
-  }
-  return pkg.version;
+  return String(getPackageJsonField('version'));
 }
 
 function packageName() {
-  const pkg = readPackageJson();
-  if (!pkg.name) {
-    fail('package.json has no name');
-  }
-  return pkg.name;
+  return String(getPackageJsonField('name'));
 }
 
 function remoteConfiguration() {
-  const pkg = readPackageJson();
-  const cfg = pkg.lastOfReadme && pkg.lastOfReadme.remote;
+  const kind = getPackageJsonField('lastOfReadme.remote.kind', { allowEmpty: true });
+  const host = getPackageJsonField('lastOfReadme.remote.host', { allowEmpty: true });
+  const repository = getPackageJsonField('lastOfReadme.remote.repository', { allowEmpty: true });
 
-  if (cfg && typeof cfg === 'object') {
-    if (cfg.kind !== 'github') {
+  if (kind !== undefined && kind !== null && kind !== '') {
+    if (kind !== 'github') {
       fail('package.json lastOfReadme.remote.kind must be "github"');
     }
-    if (!cfg.host || !cfg.repository) {
+    if (!host || !repository) {
       fail('package.json lastOfReadme.remote must include host and repository');
     }
     return {
       kind: 'github',
-      host: String(cfg.host),
-      repository: String(cfg.repository),
+      host: String(host),
+      repository: String(repository),
     };
   }
 
-  return normalizeRepositoryUrl(pkg.repository);
+  return normalizeRepositoryUrl(getPackageJsonField('repository'));
 }
 
 function remoteName() {
-  const pkg = readPackageJson();
-  const configuredRemoteName = pkg.lastOfReadme && pkg.lastOfReadme.remoteName;
+  const configuredRemoteName = getPackageJsonField('lastOfReadme.remoteName', { allowEmpty: true });
   if (configuredRemoteName && typeof configuredRemoteName === 'string') {
     return configuredRemoteName;
   }
@@ -146,6 +177,22 @@ function remoteRepository() {
   return remoteConfiguration().repository;
 }
 
+function packageFilePath() {
+  const value = getPackageJsonField('lastOfReadme.packageFilePath', { allowEmpty: true });
+  if (!value || typeof value !== 'string') {
+    fail('package.json has no lastOfReadme.packageFilePath');
+  }
+  return value;
+}
+
+function repositoryUrlPath() {
+  const value = getPackageJsonField('lastOfReadme.repositoryUrlPath', { allowEmpty: true });
+  if (value === undefined || value === null) {
+    fail('package.json has no lastOfReadme.repositoryUrlPath');
+  }
+  return String(value);
+}
+
 function readFile(relativePath) {
   const filePath = resolveWorkspacePath(relativePath);
   ensureFile(filePath, relativePath);
@@ -201,4 +248,6 @@ module.exports = {
   packageName,
   currentPackageVersion,
   remoteName,
+  packageFilePath,
+  repositoryUrlPath,
 };

package/scripts/update-readme-link.cjs

@@ -21,6 +21,23 @@ function usage() {
   process.exit(1);
 }
 
+function resolveInputs() {
+  const cliDocumentationPath = process.argv[2];
+  const cliUrlPath = process.argv[3] || '';
+
+  if (cliDocumentationPath) {
+    return {
+      documentationPath: cliDocumentationPath,
+      urlPath: cliUrlPath,
+    };
+  }
+
+  return {
+    documentationPath: workspace.packageFilePath(),
+    urlPath: workspace.repositoryUrlPath(),
+  };
+}
+
 function buildResolverLink(urlPath = '') {
   const version = workspace.currentPackageVersion();
   const packageName = workspace.packageName();
@@ -87,12 +104,7 @@ function replaceManagedBlock(content, replacement) {
 }
 
 function main() {
-  const documentationPath = process.argv[2];
-  const urlPath = process.argv[3] || '';
-
-  if (!documentationPath) {
-    usage();
-  }
+  const { documentationPath, urlPath } = resolveInputs();
 
   try {
     const link = buildResolverLink(urlPath);