npm-pkgbuild 7.3.4 → 7.3.8

package/package.json

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

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);
 

package/src/output/deb.mjs

@@ -4,9 +4,9 @@ import { createWriteStream } from "fs";
 import { mkdtemp, mkdir, chmod } from "fs/promises";
 import { pipeline } from "stream/promises";
 import { execa } from "execa";
-import { EmptyContentEntry } from "content-entry";
+import { EmptyContentEntry, ReadableStreamContentEntry } 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" };
 
@@ -17,7 +17,7 @@ const permissions = {
   "DEBIAN/postrm": executableAttributes
 };
 
-export class Deb extends Packager {
+export class DEB extends Packager {
   static get name() {
     return "deb";
   }
@@ -26,37 +26,23 @@ export class Deb extends Packager {
     return ".deb";
   }
 
+  static get fields() {
+    return fields;
+  }
+
   get packageFileName() {
     return `${this.properties.name}_${this.properties.version}_${this.properties.arch}${this.constructor.fileNameExtension}`;
   }
 
   async execute(options) {
     const properties = this.properties;
-
-    Object.entries(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;
-        }
-      }
-    });
-
+    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];
@@ -67,6 +53,19 @@ export class Deb extends Packager {
       }
     }
 
+    const debianControlName = "DEBIAN/control";
+    const transformers = [
+      {
+        match: entry => entry.name === debianControlName,
+        transform: async entry =>
+          new ReadableStreamContentEntry(
+            entry.name,
+            keyValueTransformer(await entry.readStream, controlProperties)
+          ),
+        createEntryWhenMissing: new EmptyContentEntry(debianControlName)
+      }
+    ];
+
     let debianControlEntry;
 
     for await (const entry of this.source) {
@@ -74,7 +73,7 @@ export class Deb extends Packager {
 
       await mkdir(dirname(destName), { recursive: true });
 
-      if (entry.name === "DEBIAN/control") {
+      if (entry.name === debianControlName) {
         debianControlEntry = entry;
       } else {
         console.log("ENTRY", entry.name, entry.basename);
@@ -83,7 +82,6 @@ export class Deb extends Packager {
         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);
             }
           })
@@ -92,7 +90,7 @@ export class Deb extends Packager {
     }
 
     if (!debianControlEntry) {
-      debianControlEntry = new EmptyContentEntry("DEBIAN/control");
+      debianControlEntry = new EmptyContentEntry(debianControlName);
     }
 
     let destName = join(staging, debianControlEntry.name);
@@ -127,7 +125,12 @@ const fields = {
   Priority: { type: "string", recommended: true },
   Essential: { type: "boolean" },
   Origin: { type: "string" },
-  Architecture: { alias: "arch", 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

@@ -1,3 +1,8 @@
+import { join, dirname } from "path";
+import { mkdir } from "fs/promises";
+import { pipeline } from "stream/promises";
+import { createWriteStream } from "fs";
+
 import { FileContentProvider } from "npm-pkgbuild";
 
 export const utf8StreamOptions = { encoding: "utf8" };
@@ -60,3 +65,26 @@ export function extractFromPackage(pkg) {
 
   return { properties, sources };
 }
+
+/**
+ * Copy content from source into destinationDirectory
+ * @param {AsyncIterator<ContentEntry>} source
+ * @param {string} destinationDirectory
+ * @param {Transformer[]} transformers
+ */
+export async function copyEntries(source, destinationDirectory, transformers) {
+  for await (let entry of source) {
+    const destName = join(destinationDirectory, entry.name);
+
+    await mkdir(dirname(destName), { recursive: true });
+
+    for (const t of transformers) {
+      if (t.match(entry)) {
+        entry = await t.transform(entry);
+        break;
+      }
+    }
+
+    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;
-  }
-}