npm-pkgbuild 7.4.4 → 7.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.4.4",
+  "version": "7.7.1",
   "publishConfig": {
     "access": "public"
   },
@@ -40,13 +40,14 @@
   "dependencies": {
     "aggregate-async-iterator": "^1.1.7",
     "commander": "^8.3.0",
-    "content-entry": "^2.10.0",
-    "content-entry-filesystem": "^3.1.11",
+    "content-entry": "^3.0.1",
+    "content-entry-filesystem": "^3.1.14",
     "execa": "^6.0.0",
     "expression-expander": "^7.0.9",
     "globby": "^12.0.2",
     "iterable-string-interceptor": "^1.0.8",
     "key-value-transformer": "^2.0.0",
+    "npm-package-walker": "^5.0.3",
     "npm-packlist": "^3.0.0",
     "pacote": "^12.0.2",
     "pkg-dir": "^6.0.1",

package/src/npm-pkgbuild-cli.mjs

@@ -17,16 +17,19 @@ const { version, description } = JSON.parse(
 
 const cwd = process.cwd();
 
-const outputs = [DEB, PKG, RPM];
+const allOutputs = [DEB, PKG, RPM];
 
 program.description(description).version(version);
 
-outputs.forEach(o =>
+allOutputs.forEach(o =>
   program.option(`--${o.name}`, `generate ${o.name} package`)
 );
 
 program
-  .option("--pkgver <version>", "package version")
+  .option("-D --define <a=b>", "define property", str => {
+    const kv = str.split(/=/);
+    return Object.fromEntries([kv]);
+  })
   .option("-d --destination <dir>", "where to put the package(s)", cwd)
   .option("-s --staging <dir>", "staging directory", "build")
   .option(
@@ -43,17 +46,22 @@ program
   )
   .action(async options => {
     try {
-      for (const outputFactory of outputs.filter(
-        o => options[o.name] === true
-      )) {
-        const { properties, sources } = extractFromPackage(
-          JSON.parse(
-            await readFile(
-              join(await packageDirectory(), "package.json"),
-              utf8StreamOptions
-            )
+      const pkgDir = await packageDirectory();
+
+      const { properties, sources, output } = await extractFromPackage(
+        JSON.parse(
+          await readFile(
+            join(pkgDir, "package.json"),
+            utf8StreamOptions
           )
-        );
+        ),
+        pkgDir
+      );
+
+      for (const outputFactory of allOutputs.filter(
+        o => options[o.name] === true || output[o.name] !== undefined
+      )) {
+        Object.assign(properties, options.define);
 
         sources.push(
           ...[...options.content, ...options.meta]
@@ -66,15 +74,13 @@ program
             )
         );
 
-        const context = createContext();
-        context.properties = properties;
-
+        const context = createContext({ properties });
         const output = new outputFactory(properties);
 
         const fileName = await output.execute(
           aggregateFifo(sources.map(c => c[Symbol.asyncIterator]())),
           options,
-          (object) => context.expand(object)
+          object => context.expand(object)
         );
 
         console.log(fileName);

package/src/output/deb.mjs

@@ -58,7 +58,8 @@ export class DEB extends Packager {
 
     await copyEntries(transform(sources, transformers), staging, expander, attributes);
 
-    await execa("dpkg", ["-b", staging, options.destination]);
+    const dpkg = await execa("dpkg", ["-b", staging, options.destination]);
+    //console.log(dpkg.stdout);
 
     return join(options.destination, this.packageFileName);
   }
@@ -81,7 +82,7 @@ const fields = {
   Architecture: {
     alias: "arch",
     type: "string",
-    default: "any",
+    default: "all",
     mandatory: true
   },
   Homepage: { alias: "homepage", type: "string" },

package/src/output/packager.mjs

@@ -2,15 +2,14 @@ import { join } from "path";
 import { tmpdir } from "os";
 import { mkdtemp } from "fs/promises";
 
-
 /**
  * @typedef {Object} Field
  * @property {string} alias interchangeable field name
  * @property {string} type
  * @property {any} default
- * @property {boolean} mandatory 
+ * @property {boolean} mandatory
  */
- 
+
 /**
  * @param {Object} properties
  */
@@ -61,13 +60,12 @@ export class Packager {
    * Create tmp directory.
    * @return {Promise<string>} directory path
    */
-  get tmpdir()
-  {
+  get tmpdir() {
     return mkdtemp(join(tmpdir(), this.constructor.name));
   }
 
   /**
    * Execute package generation
    */
-  async execute(sources,options) {}
+  async execute(sources, options) {}
 }

package/src/output/pkg.mjs

@@ -7,7 +7,7 @@ import {
 } from "key-value-transformer";
 import { Packager } from "./packager.mjs";
 import { copyEntries, transform } from "../util.mjs";
-import { quote } from "../util.mjs";
+import { quote, createPropertyTransformer } from "../util.mjs";
 
 /**
  * @type KeyValueTransformOptions
@@ -45,10 +45,10 @@ export class PKG extends Packager {
 
   get packageFileName() {
     const p = this.properties;
-    return `${p.name}-${p.version}-${p.release}.${p.arch}${this.constructor.fileNameExtension}`;
+    return `${p.name}-${p.version}-${p.release}-${p.arch}${this.constructor.fileNameExtension}`;
   }
 
-  async execute(sources, options,expander) {
+  async execute(sources, options, expander) {
     const properties = this.properties;
 
     //properties.depends = makeDepends({ ...pkg.engines });
@@ -80,6 +80,7 @@ package() {
     await copyEntries(transform(sources, []), join(staging, "src"), expander);
 
     const metaTransformers = [
+      createPropertyTransformer(properties),
       {
         match: entry => entry.name === "PKGBUILD",
         transform: async entry =>
@@ -94,9 +95,16 @@ package() {
       }
     ];
 
-    await copyEntries(transform(sources, metaTransformers, true), staging, expander);
+    await copyEntries(
+      transform(sources, metaTransformers, true),
+      staging,
+      expander
+    );
 
-    await execa("makepkg", ["-f"], { cwd: staging });
+    await execa("makepkg", ["-f"], {
+      cwd: staging,
+      env: { PKGDEST: options.destination }
+    });
 
     return join(options.destination, this.packageFileName);
   }

package/src/util.mjs

@@ -2,8 +2,9 @@ import { join, dirname } from "path";
 import { mkdir } from "fs/promises";
 import { pipeline } from "stream/promises";
 import { createWriteStream } from "fs";
-
+import { iterableStringInterceptor } from "iterable-string-interceptor";
 import { FileContentProvider } from "npm-pkgbuild";
+import { packageWalker } from "npm-package-walker";
 
 export const utf8StreamOptions = { encoding: "utf8" };
 
@@ -26,9 +27,10 @@ export function asArray(o) {
 /**
  * Extract package definition from package.json.
  * @param {Object} pkg package.json content
+ * @param {string} dir
  * @returns {Object}
  */
-export function extractFromPackage(pkg) {
+export async function extractFromPackage(pkg, dir) {
   const properties = Object.fromEntries(
     ["name", "version", "description", "homepage"]
       .map(key => [key, pkg[key]])
@@ -55,30 +57,60 @@ export function extractFromPackage(pkg) {
 
   let dependencies = { ...pkg.engines };
   let sources = [];
+  let output = {};
+  
+  const processPkg = pkg => {
+    if (pkg.pkgbuild) {
+      const pkgbuild = pkg.pkgbuild;
+
+      Object.assign(output, pkgbuild.output);
+      
+      Object.entries(pkgbuild)
+        .filter(([k, v]) => typeof v === "string")
+        .forEach(([k, v]) => (properties[k] = v));
+
+      if (pkgbuild.content) {
+        sources = Object.entries(pkgbuild.content).map(
+          ([destination, value]) =>
+            new FileContentProvider(value, { destination })
+        );
+      }
 
-  if (pkg.pkgbuild) {
-    const pkgbuild = pkg.pkgbuild;
-    Object.entries(pkgbuild)
-      .filter(([k, v]) => typeof v === "string")
-      .forEach(([k, v]) => (properties[k] = v));
-
-    if (pkgbuild.content) {
-      sources = Object.entries(pkgbuild.content).map(
-        ([destination, value]) =>
-          new FileContentProvider(value, { destination })
-      );
+      Object.assign(dependencies, pkgbuild.depends);
     }
+  };
+
+  await packageWalker(async (pkg, base, modulePath) => {
+    processPkg(pkg)
+    return true;
+  }, dir);
+
+  processPkg(pkg);
 
-    Object.assign(dependencies, pkgbuild.depends);
+  return { properties, sources, dependencies, output };
+}
+
+export function createPropertyTransformer(properties) {
+  async function* transformer(expression, remainder, source, cb) {
+    console.log("EXPRESSION", expression);
+    yield properties[expression];
   }
 
-  return { properties, sources, dependencies };
+  return {
+    match: entry => true, //entry.name.match(/(conf|json)$/),
+    transform: async entry =>
+      new ReadableStreamContentEntry(
+        entry.name,
+        iterableStringInterceptor(transformer)
+      )
+  };
 }
 
 /**
- * Apply transformers
+ * Apply transformers.
  * @param {AsyncIterator<ContentEntry>} source
  * @param {Transformer[]} transformers
+ * @param {Boolean]} onlyMatching filter out all none matching entries
  */
 export async function* transform(source, transformers = [], onlyMatching) {
   const usedTransformers = new Set();
@@ -117,11 +149,17 @@ export async function* transform(source, transformers = [], onlyMatching) {
 export async function copyEntries(
   source,
   destinationDirectory,
-  expander = (v) => v,
+  expander = v => v,
   attributes = []
 ) {
   for await (let entry of source) {
-    const destName = expander(entry.destination === undefined ? join(destinationDirectory, entry.name) : join(destinationDirectory, entry.destination, entry.name));
+    const destName = expander(
+      entry.destination === undefined
+        ? join(destinationDirectory, entry.name)
+        : entry.destination.endsWith("/")
+        ? join(destinationDirectory, entry.destination, entry.name)
+        : join(destinationDirectory, entry.destination)
+    );
     await mkdir(dirname(destName), { recursive: true });
 
     const options = { mode: entry.mode };