npm-pkgbuild 7.3.14 → 7.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.3.14",
+  "version": "7.4.0",
   "publishConfig": {
     "access": "public"
   },
@@ -46,7 +46,7 @@
     "expression-expander": "^7.0.9",
     "globby": "^12.0.2",
     "iterable-string-interceptor": "^1.0.8",
-    "key-value-transformer": "^1.1.0",
+    "key-value-transformer": "^2.0.0",
     "npm-packlist": "^3.0.0",
     "pacote": "^12.0.2",
     "pkg-dir": "^6.0.1",

package/src/output/deb.mjs

@@ -92,7 +92,7 @@ const fields = {
   Breaks: { type: "packageList" },
   Replaces: { type: "packageList" },
 
-  Source: {},
+  Source: { alias: "source", type: "string" },
   Uploaders: { mandatory: false },
   "Installed-Size": {}
 };

package/src/output/packager.mjs

@@ -36,7 +36,7 @@ export class Packager {
         properties[k] = e;
       } else {
         if (v.default !== undefined) {
-          properties[v.alias] = v.default;
+          properties[v.alias || k] = v.default;
         }
       }
     });

package/src/output/pkg.mjs

@@ -1,13 +1,34 @@
-import { join } from "path";
-import { createWriteStream } from "fs";
-import { tmpdir } from "os";
-import { finished } from "stream";
-import { promisify } from "util";
-import { mkdtemp, mkdir, chmod } from "fs/promises";
 import { execa } from "execa";
+import { EmptyContentEntry, ReadableStreamContentEntry } from "content-entry";
+import {
+  keyValueTransformer,
+  equalSeparatedKeyValuePairOptions
+} from "key-value-transformer";
 import { Packager } from "./packager.mjs";
+import { copyEntries, transform } from "../util.mjs";
 import { quote } from "../util.mjs";
 
+/**
+ * @type KeyValueTransformOptions
+ * Options to describe key value pair separated by an equal sign '='
+ */
+export const pkgKeyValuePairOptions = {
+  ...equalSeparatedKeyValuePairOptions,
+
+  extractKeyValue: line => {
+    const m = line.match(/^(\w+)=\s*\((.*)\)|(.*)/);
+    if (m) {
+      return [m[1], m[2] ? [m[2]] : m[3]];
+    }
+  },
+  keyValueLine: (key, value, lineEnding) =>
+    `${key}=${
+      Array.isArray(value)
+        ? "(" + value.map(v => quote(v)).join(",") + ")"
+        : quote(value)
+    }${lineEnding}`
+};
+
 export class PKG extends Packager {
   static get name() {
     return "pkg";
@@ -26,27 +47,45 @@ export class PKG extends Packager {
     const mandatoryFields = this.mandatoryFields;
     const staging = await this.tmpdir;
 
-    const pkgbuildFileName = join(tmp, "PKGBUILD");
+    function* controlProperties(k, v, presentKeys) {
+      if (k === undefined) {
+        for (const p of mandatoryFields) {
+          if (!presentKeys.has(p)) {
+            const v = properties[p];
+            yield [p, v === undefined ? fields[p].default : v];
+          }
+        }
+      } else {
+        yield [k, properties[k] || v];
+      }
+    }
 
-    this.writePkbuild(pkgbuildFileName);
+    async function* trailingLines() {
+      yield `
+package() {
+  cp -r $srcdir/* "$pkgdir"
+}
+`;
+    }
 
-    const transformers = [];
+    const transformers = [
+      {
+        match: entry => entry.name === "PKGBUILD",
+        transform: async entry =>
+          new ReadableStreamContentEntry(
+            entry.name,
+            keyValueTransformer(await entry.readStream, controlProperties, {
+              ...pkgKeyValuePairOptions,
+              trailingLines
+            })
+          ),
+        createEntryWhenMissing: () => new EmptyContentEntry("PKGBUILD")
+      }
+    ];
 
     await copyEntries(transform(sources, transformers), staging);
 
-    await execa("makepkg", [], { cwd: staging });
-  }
-
-  writePkbuild(pkgbuildFileName) {
-    const out = createWriteStream(pkgbuildFileName, { encoding: "utf8" });
-
-    out.write(`
-package() {
-   cp -r $srcdir/* "$pkgdir"
-}
-`);
-
-    out.end();
+    await execa("makepkg", ["-f"], { cwd: staging });
   }
 }
 
@@ -55,18 +94,22 @@ package() {
  * https://www.archlinux.org/pacman/PKGBUILD.5.html
  */
 const fields = {
-  pkgname: { alias: "name", type: "string[]" },
-  license: { type: "string[]" },
-  source: { type: "string[]" },
+  pkgname: { alias: "name", type: "string[]", mandatory: true },
+  pkgver: { alias: "version", type: "string", mandatory: true },
+  pkgrel: { alias: "release", type: "integer", default: 0, mandatory: true },
+  pkgdesc: { alias: "description", type: "string", mandatory: true },
+  arch: { default: ["any"], type: "string[]", mandatory: true },
+
+  license: { type: "string[]", mandatory: true },
+  source: { default: [], type: "string[]" },
   validpgpkeys: { type: "string[]" },
   noextract: { type: "string[]" },
-  md5sums: { type: "string[]" },
+  md5sums: { /*default: ["SKIP"],*/ type: "string[]" },
   sha1sums: { type: "string[]" },
   sha256sums: { type: "string[]" },
   sha384sums: { type: "string[]" },
   sha512sums: { type: "string[]" },
   groups: { type: "string[]" },
-  arch: { type: "string[]" },
   backup: { type: "string[]" },
   depends: { type: "string[]" },
   makedepends: { type: "string[]" },
@@ -77,80 +120,28 @@ const fields = {
   replaces: { type: "string[]" },
   options: { type: "string[]" },
 
-  pkgver: {},
-  pkgrel: {},
   epoch: {},
-  pkgdesc: {},
-  url: {},
+  url: { alias: "homepage", type: "string" },
   install: {},
   changelog: {}
 };
 
 /*
-export async function pkgbuild(context, stagingDir, out, options = {}) {
-  const pkg = { contributors: [], pacman: {}, ...context.pkg };
-
-  let md5sums;
-  let source;
-  let directory = "";
-
   if (pkg.repository) {
     source = pkg.repository.url;
     if (!source.startsWith("git+")) {
       source = "git+" + source;
     }
 
-    md5sums = "SKIP";
-
     directory = pkg.repository.directory ? "/" + pkg.repository.directory : "";
   }
 
   const properties = {
-    url: pkg.homepage,
-    pkgdesc: pkg.description,
-    license: pkg.license,
-    pkgrel: context.properties.pkgrel,
-    pkgver: context.properties.pkgver.replace(/\-.*$/, ""),
-    pkgname: pkg.name,
-    arch: "any",
-    makedepends: "git",
-    source,
-    md5sums
+    makedepends: "git"
   };
 
-  optionsPKGBUILD.forEach(k => {
-    const v = pkg.pacman[k];
-    if (v !== undefined) {
-      properties[k] = v;
-    }
-  });
-
   properties.depends = makeDepends({ ...pkg.engines });
 
-  if (properties.install !== undefined || properties.hooks !== undefined) {
-    properties.install = `${pkg.name}.install`;
-  }
-
-  const installdir = context.properties.installdir;
-
-  arrayOptionsPKGBUILD.forEach(k => {
-    const v = properties[k];
-    if (v !== undefined && !Array.isArray(v)) {
-      properties[k] = [v];
-    }
-  });
-
-  let pkgver = "";
-
-  if (context.properties.pkgver === "0.0.0-semantic-release") {
-    pkgver = `
-pkgver() {
-  cd "$pkgname"
-  printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
-}
-`;
-  }
-
   out.write(
     `# ${pkg.contributors
       .map(
@@ -183,9 +174,6 @@ package() {
 `
   );
 
-  await promisify(finished);
-}
-
 function makeDepends(d) {
   if (d === undefined) {
     return [];

package/src/output/rpm.mjs

@@ -1,5 +1,13 @@
-import { globby } from "globby";
+import { join } from "path";
+import { mkdir } from "fs/promises";
+import { execa } from "execa";
+import { EmptyContentEntry, ReadableStreamContentEntry } from "content-entry";
+import {
+  keyValueTransformer,
+  colonSeparatedKeyValuePairOptions
+} from "key-value-transformer";
 import { Packager } from "./packager.mjs";
+import { copyEntries, transform } from "../util.mjs";
 
 export class RPM extends Packager {
   static get name() {
@@ -10,36 +18,99 @@ export class RPM extends Packager {
     return ".rpm";
   }
 
+  get packageFileName() {
+    const p = this.properties;
+    return `${p.name}-${p.version}-${p.release}.${p.arch}${this.constructor.fileNameExtension}`;
+  }
+
   static get fields() {
     return fields;
   }
 
-  async execute(sources,options) {
+  async execute(sources, options) {
     const properties = this.properties;
     const mandatoryFields = this.mandatoryFields;
-    const staging = await this.tmpdir;
-
-    let specFileName = `${properties.name}.spec`;
+    const tmp = await this.tmpdir;
 
-    const transformers = [];
-
-    await copyEntries(
-      transform(sources, transformers),
-      staging
+    await Promise.all(
+      ["staging", "RPMS", "SRPMS", "SOURCES", "SPECS"].map(d =>
+        mkdir(join(tmp, d))
+      )
     );
 
-    await execa("rpmbuild", ["-ba", specFileName]);
+    const staging = join(tmp, "staging");
+
+    function* controlProperties(k, v, presentKeys) {
+      if (k === undefined) {
+        for (const p of mandatoryFields) {
+          if (!presentKeys.has(p)) {
+            const v = properties[p];
+            yield [p, v === undefined ? fields[p].default : v];
+          }
+        }
+      } else {
+        yield [k, properties[k] || v];
+      }
+    }
+
+    const specFileName = `${properties.name}.spec`;
+
+    async function* trailingLines() {
+      for (const [name, options] of Object.entries(sections)) {
+        yield `%${name}\n\n`;
+      }
+    }
+
+    const transformers = [
+      {
+        match: entry => entry.name === specFileName,
+        transform: async entry =>
+          new ReadableStreamContentEntry(
+            entry.name,
+            keyValueTransformer(await entry.readStream, controlProperties, {
+              ...colonSeparatedKeyValuePairOptions,
+              trailingLines
+            })
+          ),
+        createEntryWhenMissing: () => new EmptyContentEntry(specFileName)
+      }
+    ];
+
+    await copyEntries(transform(sources, transformers), staging);
+
+    await execa("rpmbuild", [
+      "--define",
+      `_topdir ${tmp}`,
+      "-vv",
+      "-bb",
+      //  `--target=${properties.arch}`,
+      join(staging, specFileName)
+    ]);
+
+    return join(options.destination, this.packageFileName);
   }
 }
 
+/**
+ * @see https://rpm-packaging-guide.github.io
+ */
 const fields = {
-  Name: { alias: "name", type: "string" },
-  Summary: { alias: "description", type: "string" },
-  License: { alias: "license", type: "string" },
-  Version: { alias: "version", type: "string" },
-  Release: { type: "integer", default: 0 },
+  Name: { alias: "name", type: "string", mandatory: true },
+  Summary: { alias: "description", type: "string", mandatory: true },
+  License: { alias: "license", type: "string", mandatory: true },
+  Version: { alias: "version", type: "string", mandatory: true },
+  Release: { alias: "release", type: "integer", default: 1, mandatory: true },
+  Source0: { alias: "source", type: "string" },
+  Group: { alias: "group", type: "string" },
   Packager: { type: "string" },
-  URL: { alias: "homepage", type: "string" }
+  BuildArch: {
+    alias: "arch",
+    default: "noarch",
+    type: "string",
+    mandatory: true
+  },
+  URL: { alias: "homepage", type: "string" },
+  Requires: { type: "string[]" }
 };
 
 const sections = {
@@ -47,50 +118,7 @@ const sections = {
   prep: {},
   build: {},
   install: {},
+  check: {},
   files: {},
   changelog: {}
 };
-
-export async function rpmspec(context, stagingDir, out, options = {}) {
-  const pkg = { contributors: [], pacman: {}, ...context.pkg };
-
-  const installdir = context.properties.installdir;
-  let directory = "";
-
-  const npmDistPackage = options.npmDist
-    ? `( cd %{_sourcedir}${installdir}
-  tar -x --transform="s/^package\\///" -f %{buildroot}${directory}/${pkg.name}-${context.properties.pkgver}.tgz)`
-    : "";
-
-  const npmModulesPackage = options.npmModules
-    ? `( cd %{_sourcedir}/${directory}
-  tar cf - node_modules)|(cd %{buildroot}${installdir};tar xf - )`
-    : "";
-
-  out.write(`${Object.keys(properties)
-    .filter(k => properties[k] !== undefined)
-    .map(k => `${k}: ${properties[k]}`)
-    .join("\n")}
-
-%description
-${pkg.description}
-
-%build
-npm install
-mkdir -p %{buildroot}${installdir}
-${npmDistPackage}
-${npmModulesPackage}
-
-%install
-
-%files
-${installdir}bin/*
-${installdir}node_modules/*
-`);
-
-  for (const name of await globby("**/*", { cwd: stagingDir })) {
-    out.write(name + "\n");
-  }
-
-  out.end();
-}

package/src/util.mjs

@@ -49,17 +49,23 @@ export function extractFromPackage(pkg) {
     )[0];
   }
 
+  if (pkg.repository) {
+    properties.source = pkg.repository.url;
+  }
+
   let sources = [];
 
   if (pkg.pkgbuild) {
-    Object.entries(pkg.pkgbuild)
+    const pkgbuild = pkg.pkgbuild;
+    Object.entries(pkgbuild)
       .filter(([k, v]) => typeof v === "string")
       .forEach(([k, v]) => (properties[k] = v));
 
-    if (pkg.pkgbuild.content) {
-      sources = Object.entries(pkg.pkgbuild.content).map(
-        ([destination, value]) => [new FileContentProvider(value), destination]
-      );
+    if (pkgbuild.content) {
+      sources = Object.entries(pkgbuild.content).map(([destination, value]) => [
+        new FileContentProvider(value),
+        destination
+      ]);
     }
   }
 
@@ -114,6 +120,7 @@ export async function copyEntries(
       }
     }
 
+    console.log(destName);
     await pipeline(
       await entry.readStream,
       createWriteStream(destName, options)