npm-pkgbuild 7.3.2 → 7.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.3.2",
+  "version": "7.3.6",
   "publishConfig": {
     "access": "public"
   },
@@ -40,12 +40,13 @@
   "dependencies": {
     "aggregate-async-iterator": "^1.1.7",
     "commander": "^8.3.0",
-    "content-entry": "^2.7.1",
-    "content-entry-filesystem": "^3.0.1",
-    "execa": "^5.1.1",
+    "content-entry": "^2.9.6",
+    "content-entry-filesystem": "^3.1.9",
+    "execa": "^6.0.0",
     "expression-expander": "^7.0.9",
     "globby": "^12.0.2",
     "iterable-string-interceptor": "^1.0.8",
+    "key-value-transformer": "^1.0.0",
     "npm-packlist": "^3.0.0",
     "pacote": "^12.0.2",
     "pkg-dir": "^6.0.1",
@@ -55,11 +56,11 @@
     "ava": "^3.15.0",
     "c8": "^7.10.0",
     "documentation": "^13.2.5",
-    "semantic-release": "^18.0.0",
+    "semantic-release": "^18.0.1",
     "stream-buffers": "^3.0.2"
   },
   "engines": {
-    "node": ">=16.12.0"
+    "node": ">=16.13.0"
   },
   "repository": {
     "type": "git",

package/src/module.mjs

@@ -6,4 +6,5 @@ export * from "./content/node-modules-content-provider.mjs";
 export * from "./content/npm-pack-content-provider.mjs";
 export * from "./output/deb.mjs";
 export * from "./output/rpm.mjs";
-export * from "./output/pkg.mjs";
+export * from "./output/pkg.mjs";
+export * from "./output/packager.mjs";

package/src/npm-pkgbuild-cli.mjs

@@ -7,7 +7,7 @@ import program from "commander";
 import { aggregateFifo } from "aggregate-async-iterator";
 import { packageDirectory } from "pkg-dir";
 import { utf8StreamOptions, extractFromPackage } from "./util.mjs";
-import { FileContentProvider, Deb, PKG, RPM } from "npm-pkgbuild";
+import { FileContentProvider, DEB, PKG, RPM } from "npm-pkgbuild";
 
 const { version, description } = JSON.parse(
   readFileSync(new URL("../package.json", import.meta.url).pathname),
@@ -16,7 +16,7 @@ const { version, description } = JSON.parse(
 
 const cwd = process.cwd();
 
-const outputs = [Deb, PKG, RPM];
+const outputs = [DEB, PKG, RPM];
 
 program.description(description).version(version);
 
@@ -26,7 +26,7 @@ outputs.forEach(o =>
 
 program
   .option("--pkgver <version>", "package version")
-  .option("-p --package <dir>", "where to put the package(s)", cwd)
+  .option("-d --destination <dir>", "where to put the package(s)", cwd)
   .option("-s --staging <dir>", "staging directory", "build")
   .option(
     "-c --content <dir>",
@@ -70,7 +70,7 @@ program
           properties
         );
 
-        const fileName = await output.execute();
+        const fileName = await output.execute(options);
 
         console.log(fileName);
       }

package/src/output/deb.mjs

@@ -3,19 +3,21 @@ import { tmpdir } from "os";
 import { createWriteStream } from "fs";
 import { mkdtemp, mkdir, chmod } from "fs/promises";
 import { pipeline } from "stream/promises";
-import execa from "execa";
+import { execa } from "execa";
 import { EmptyContentEntry } from "content-entry";
+import { keyValueTransformer } from "key-value-transformer";
 import { Packager } from "./packager.mjs";
-import { keyValueTransformer } from "../key-value-transformer.mjs";
+
+const executableAttributes = { chmod: "0775" };
 
 const permissions = {
-  "DEBIAN/preinst": { chmod: "0775" },
-  "DEBIAN/postinst": { chmod: "0775" },
-  "DEBIAN/prerm": { chmod: "0775" },
-  "DEBIAN/postrm": { chmod: "0775" }
+  "DEBIAN/preinst": executableAttributes,
+  "DEBIAN/postinst": executableAttributes,
+  "DEBIAN/prerm": executableAttributes,
+  "DEBIAN/postrm": executableAttributes
 };
 
-export class Deb extends Packager {
+export class DEB extends Packager {
   static get name() {
     return "deb";
   }
@@ -24,28 +26,23 @@ export class Deb extends Packager {
     return ".deb";
   }
 
-  async execute() {
-    const properties = this.properties;
+  static get fields() {
+    return fields;
+  }
 
-    Object.entries(fields).forEach(([k, v]) => {
-      const e = properties[v.alias];
-      if (e !== undefined) {
-        properties[k] = e;
-      }
-    });
+  get packageFileName() {
+    return `${this.properties.name}_${this.properties.version}_${this.properties.arch}${this.constructor.fileNameExtension}`;
+  }
 
+  async execute(options) {
+    const properties = this.properties;
+    const mandatoryFields = this.mandatoryFields;
     const tmp = await mkdtemp(join(tmpdir(), "deb-"));
     const staging = join(tmp, `${properties.name}-${properties.version}`);
 
-    const mandatoryProperties = new Set(
-      Object.entries(fields)
-        .filter(([k, v]) => v.mandatory)
-        .map(([k, v]) => k)
-    );
-
     function* controlProperties(k, v, presentKeys) {
       if (k === undefined) {
-        for (const p of mandatoryProperties) {
+        for (const p of mandatoryFields) {
           if (!presentKeys.has(p)) {
             const v = properties[p];
             yield [p, v === undefined ? fields[p].default : v];
@@ -56,7 +53,15 @@ export class Deb extends Packager {
       }
     }
 
-    const output = `${staging}${this.constructor.fileNameExtension}`;
+    const debianControlName = "DEBIAN/control";
+    const transformers = [
+      {
+        match: entry => entry.name === debianControlName,
+        transform: async entry =>
+          keyValueTransformer(await entry.readStream, controlProperties),
+        createEntryWhenMissing: new EmptyContentEntry(debianControlName)
+        }
+    ];
 
     let debianControlEntry;
 
@@ -65,18 +70,15 @@ export class Deb extends Packager {
 
       await mkdir(dirname(destName), { recursive: true });
 
-      if (entry.name === "DEBIAN/control") {
+      if (entry.name === debianControlName) {
         debianControlEntry = entry;
       } else {
-        await pipeline(
-          await entry.getReadStream(),
-          createWriteStream(destName)
-        );
+        console.log("ENTRY", entry.name, entry.basename);
+        await pipeline(await entry.readStream, createWriteStream(destName));
 
         await Promise.all(
           Object.entries(permissions).map(async ([pattern, option]) => {
             if (destName.endsWith(pattern)) {
-              //console.log("CHMOD", option.chmod, destName, pattern);
               return chmod(destName, option.chmod);
             }
           })
@@ -85,7 +87,7 @@ export class Deb extends Packager {
     }
 
     if (!debianControlEntry) {
-      debianControlEntry = new EmptyContentEntry("DEBIAN/control");
+      debianControlEntry = new EmptyContentEntry(debianControlName);
     }
 
     let destName = join(staging, debianControlEntry.name);
@@ -94,15 +96,15 @@ export class Deb extends Packager {
 
     await pipeline(
       keyValueTransformer(
-        await debianControlEntry.getReadStream(),
+        await debianControlEntry.readStream,
         controlProperties
       ),
       createWriteStream(destName)
     );
 
-    await execa("dpkg", ["-b", staging]);
+    await execa("dpkg", ["-b", staging, options.destination]);
 
-    return output;
+    return join(options.destination, this.packageFileName);
   }
 }
 
@@ -120,7 +122,12 @@ const fields = {
   Priority: { type: "string", recommended: true },
   Essential: { type: "boolean" },
   Origin: { type: "string" },
-  Architecture: { type: "string", default: "any", mandatory: true },
+  Architecture: {
+    alias: "arch",
+    type: "string",
+    default: "any",
+    mandatory: true
+  },
   Homepage: { alias: "homepage", type: "string" },
   Bugs: { alias: "bugs", type: "string" },
   Depends: { alias: "depends", type: "packageList" },

package/src/output/packager.mjs

@@ -1,8 +1,60 @@
+/**
+ * @typedef {Object} Field
+ * @property {string} alias interchangeable field name
+ * @property {string} type
+ * @property {any} default
+ * @property {boolean} mandatory 
+ */
+ 
+/**
+ * @param {Object} properties
+ */
 export class Packager {
+  static get fields() {
+    return {};
+  }
+
   constructor(source, properties) {
     this.source = source;
-    this.properties = properties;
+    this._properties = properties;
+  }
+
+  get fields() {
+    return this.constructor.fields;
+  }
+
+  get properties() {
+    const properties = this._properties;
+
+    Object.entries(this.fields).forEach(([k, v]) => {
+      const e = properties[v.alias];
+      if (e !== undefined) {
+        properties[k] = e;
+      } else {
+        if (v.default !== undefined) {
+          properties[v.alias] = v.default;
+        }
+      }
+    });
+
+    return properties;
+  }
+
+  /**
+   * @return {Set<string,Field>} mandatory fields
+   */
+  get mandatoryFields() {
+    const mandatoryFields = new Set(
+      Object.entries(this.fields)
+        .filter(([k, v]) => v.mandatory)
+        .map(([k, v]) => k)
+    );
+
+    return mandatoryFields;
   }
 
+  /**
+   * Execute package generation
+   */
   async execute() {}
 }

package/src/output/pkg.mjs

@@ -1,67 +1,86 @@
-import { join, dirname } from "path";
+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 { execa } from "execa";
 import { Packager } from "./packager.mjs";
 import { quote } from "../util.mjs";
 
 export class PKG extends Packager {
-
-  static get name() { return "pkg"; }
+  static get name() {
+    return "pkg";
+  }
 
   static get fileNameExtension() {
-    return ".pkg.tar";
+    return ".pkg.tar.zst";
   }
 
-  async execute() {
+  static get fields() {
+    return fields;
+  }
 
+  async execute(options) {
     const tmp = await mkdtemp(join(tmpdir(), "pkg-"));
 
+    const pkgbuildFileName = join(tmp, "PKGBUILD");
+
+    this.writePkbuild(pkgbuildFileName);
+
     await execa("makepkg", [], { cwd: tmp });
   }
+
+  writePkbuild(pkgbuildFileName) {
+    const out = createWriteStream(pkgbuildFileName, { encoding: "utf8" });
+
+    out.write(`
+package() {
+   cp -r $srcdir/* "$pkgdir"
+}
+`);
+
+    out.end();
+  }
 }
 
 /**
  * well known package properties
  * https://www.archlinux.org/pacman/PKGBUILD.5.html
  */
-const arrayOptionsPKGBUILD = [
-  "pkgname",
-  "license",
-  "source",
-  "validpgpkeys",
-  "noextract",
-  "md5sums",
-  "sha1sums",
-  "sha256sums",
-  "sha384sums",
-  "sha512sums",
-  "groups",
-  "arch",
-  "backup",
-  "depends",
-  "makedepends",
-  "checkdepends",
-  "optdepends",
-  "conflicts",
-  "provides",
-  "replaces",
-  "options"
-];
-
-const optionsPKGBUILD = [
-  ...arrayOptionsPKGBUILD,
-  "pkgver",
-  "pkgrel",
-  "epoch",
-  "pkgdesc",
-  "url",
-  "install",
-  "changelog"
-];
-
+const fields = {
+  pkgname: { alias: "name", type: "string[]" },
+  license: { type: "string[]" },
+  source: { type: "string[]" },
+  validpgpkeys: { type: "string[]" },
+  noextract: { type: "string[]" },
+  md5sums: { 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[]" },
+  checkdepends: { type: "string[]" },
+  optdepends: { type: "string[]" },
+  conflicts: { type: "string[]" },
+  provides: { type: "string[]" },
+  replaces: { type: "string[]" },
+  options: { type: "string[]" },
+
+  pkgver: {},
+  pkgrel: {},
+  epoch: {},
+  pkgdesc: {},
+  url: {},
+  install: {},
+  changelog: {}
+};
+
+/*
 export async function pkgbuild(context, stagingDir, out, options = {}) {
   const pkg = { contributors: [], pacman: {}, ...context.pkg };
 
@@ -139,7 +158,7 @@ ${Object.keys(properties)
 ${pkgver}
 build() {
   cd \${pkgname}${directory}
-  sed -i 's/"version": ".*/"version": "${
+  sed -i 's/"version": ".* /"version": "${
     context.properties.pkgver
   }",/' package.json
   npm install
@@ -158,8 +177,6 @@ package() {
 `
   );
 
-  out.end();
-
   await promisify(finished);
 }
 
@@ -177,3 +194,4 @@ function makeDepends(d) {
     return a;
   }, []);
 }
+*/

package/src/output/rpm.mjs

@@ -1,35 +1,59 @@
 import { globby } from "globby";
 import { Packager } from "./packager.mjs";
 
-
 export class RPM extends Packager {
-  static get name() { return "rpm"; }
+  static get name() {
+    return "rpm";
+  }
 
   static get fileNameExtension() {
     return ".rpm";
   }
+
+  static get fields() {
+    return fields;
+  }
+
+  async execute(options) {
+    const properties = this.properties;
+    const mandatoryFields = this.mandatoryFields;
+
+    const tmp = await mkdtemp(join(tmpdir(), "deb-"));
+    const staging = join(tmp, `${properties.name}-${properties.version}`);
+
+    let specFileName = ".spec";
+
+    //if (entry.name === ".spec")
+
+    await execa("rpmbuild", ["-ba", specFileName]);
+  }
 }
 
+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 },
+  Packager: { type: "string" },
+  URL: { alias: "homepage", type: "string" }
+};
+
+const sections = {
+  description: {},
+  prep: {},
+  build: {},
+  install: {},
+  files: {},
+  changelog: {}
+};
+
 export async function rpmspec(context, stagingDir, out, options = {}) {
   const pkg = { contributors: [], pacman: {}, ...context.pkg };
 
   const installdir = context.properties.installdir;
   let directory = "";
 
-  if (pkg.repository) {
-    directory = pkg.repository.directory ? "/" + pkg.repository.directory : "";
-  }
-
-  const properties = {
-    Name: pkg.name,
-    Summary: pkg.description,
-    License: pkg.license,
-    Version: context.properties.pkgver.replace(/\-.*$/, ""),
-    Release: context.properties.pkgrel,
-    Packager: pkg.contributors.map((c, i) => `${c.name} <${c.email}>`)[0],
-    URL: pkg.homepage
-  };
-
   const npmDistPackage = options.npmDist
     ? `( cd %{_sourcedir}${installdir}
   tar -x --transform="s/^package\\///" -f %{buildroot}${directory}/${pkg.name}-${context.properties.pkgver}.tgz)`
@@ -48,8 +72,6 @@ export async function rpmspec(context, stagingDir, out, options = {}) {
 %description
 ${pkg.description}
 
-%prep
-
 %build
 npm install
 mkdir -p %{buildroot}${installdir}

package/src/util.mjs

@@ -60,3 +60,30 @@ export function extractFromPackage(pkg) {
 
   return { properties, sources };
 }
+
+/**
+ * Copy content from source into destinationDirectory
+ * @param {AsyncIterator<ContentEntry>} source 
+ * @param {string} destinationDirectory 
+ */
+async function copyEntries(source, destinationDirectory, transformers) {
+  for await (const entry of source) {
+    const destName = join(destinationDirectory, entry.name);
+
+    await mkdir(dirname(destName), { recursive: true });
+
+    for(const t of transformers) {
+      if(t.match(entry)) {
+        t.transform(entry);
+
+        break;
+      }
+    }
+
+    if (entry.name === "DEBIAN/control") {
+      debianControlEntry = entry;
+    } else {
+      await pipeline(await entry.readStream, createWriteStream(destName));
+    }
+  }
+}

package/src/key-value-transformer.mjs

@@ -1,62 +0,0 @@
-/**
- * Replaces key value pairs in a stream of lines.
- * @param {AsyncIterator<String>} source
- * @param updates
- */
-export async function* keyValueTransformer(source, updates) {
-  const presentKeys = new Set();
-
-  let key, value;
-
-  function* eject() {
-    if (key !== undefined) {
-      for(const [k,v] of updates(key, value, presentKeys)) {
-        yield `${k}: ${v}\n`;
-      }
-      key = value = undefined;
-    }
-  }
-
-  for await (const line of asLines(source)) {
-    const m = line.match(/^(\w+):\s*(.*)/);
-    if (m) {
-      yield* eject();
-      key = m[1];
-      value = m[2];
-      presentKeys.add(key);
-    } else if (key !== undefined) {
-      const m = line.match(/^\s+(.*)/);
-      if (m) {
-        value += m[1];
-      } else {
-        yield* eject();
-        yield line + "\n";
-      }
-    } else {
-      yield line + "\n";
-    }
-  }
-
-  yield* eject();
-
-  for(const [k,v] of updates(undefined, undefined, presentKeys)) {
-    yield `${k}: ${v}\n`;
-  }
-}
-
-async function* asLines(source) {
-  let buffer = "";
-
-  for await (let chunk of source) {
-    buffer += chunk.toString();
-    const lines = buffer.split(/\n\r?/);
-    buffer = lines.pop();
-    for (const line of lines) {
-      yield line;
-    }
-  }
-
-  if (buffer.length > 0) {
-    yield buffer;
-  }
-}