npm-pkgbuild 7.3.14 → 7.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.3.14",
+  "version": "7.4.3",
   "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/content/file-content-provider.mjs

@@ -11,7 +11,7 @@ import { ContentProvider } from "./content-provider.mjs";
  * @param {string} definitions.base base directory where to find the files
  */
 export class FileContentProvider extends ContentProvider {
-  constructor(definitions) {
+  constructor(definitions, entryProperties) {
     super();
 
     if (typeof definitions === "string") {
@@ -24,6 +24,8 @@ export class FileContentProvider extends ContentProvider {
       this.definitions = { pattern: ["**/*"], ...definitions };
       this.definitions.pattern = asArray(this.definitions.pattern);
     }
+
+    this.entryProperties = entryProperties;
   }
 
   async *[Symbol.asyncIterator]() {
@@ -33,7 +35,9 @@ export class FileContentProvider extends ContentProvider {
     for (const name of await globby(definitions.pattern, {
       cwd: base
     })) {
-      yield new FileSystemEntry(name, base);
+      const entry = new FileSystemEntry(name, base);
+      Object.assign(entry, this.entryProperties);
+      yield entry;
     }
   }
 }

package/src/npm-pkgbuild-cli.mjs

@@ -57,17 +57,20 @@ program
         sources.push(
           ...[...options.content, ...options.meta]
             .filter(x => x)
-            .map(source => [
-              new FileContentProvider({
-                base: source
-              }),
-              ""
-            ])
+            .map(
+              source =>
+                new FileContentProvider({
+                  base: source
+                })
+            )
         );
 
         const output = new outputFactory(properties);
 
-        const fileName = await output.execute(aggregateFifo(sources.map(([c, d]) => c[Symbol.asyncIterator]() )), options);
+        const fileName = await output.execute(
+          aggregateFifo(sources.map(c => c[Symbol.asyncIterator]())),
+          options
+        );
 
         console.log(fileName);
       }

package/src/output/deb.mjs

@@ -21,7 +21,8 @@ export class DEB extends Packager {
   }
 
   get packageFileName() {
-    return `${this.properties.name}_${this.properties.version}_${this.properties.arch}${this.constructor.fileNameExtension}`;
+    const p = this.properties;
+    return `${p.name}_${p.version}_${p.arch}${this.constructor.fileNameExtension}`;
   }
 
   async execute(sources, options) {
@@ -92,7 +93,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,35 @@
 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].split(/\s*,\s*/)] : 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";
@@ -21,32 +43,62 @@ export class PKG extends Packager {
     return fields;
   }
 
+  get packageFileName() {
+    const p = this.properties;
+    return `${p.name}-${p.version}-${p.release}.${p.arch}${this.constructor.fileNameExtension}`;
+  }
+
   async execute(sources, options) {
     const properties = this.properties;
+
+    //properties.depends = makeDepends({ ...pkg.engines });
+
     const mandatoryFields = this.mandatoryFields;
     const staging = await this.tmpdir;
 
-    const pkgbuildFileName = join(tmp, "PKGBUILD");
-
-    this.writePkbuild(pkgbuildFileName);
+    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 transformers = [];
+    async function* trailingLines() {
+      yield `
+package() {
+  cp -r $srcdir/* "$pkgdir"
+}
+`;
+    }
 
-    await copyEntries(transform(sources, transformers), staging);
+    await copyEntries(transform(sources, []), join(staging, "src"));
 
-    await execa("makepkg", [], { cwd: staging });
-  }
+    const metaTransformers = [
+      {
+        match: entry => entry.name === "PKGBUILD",
+        transform: async entry =>
+          new ReadableStreamContentEntry(
+            entry.name,
+            keyValueTransformer(await entry.readStream, controlProperties, {
+              ...pkgKeyValuePairOptions,
+              trailingLines
+            })
+          ),
+        createEntryWhenMissing: () => new EmptyContentEntry("PKGBUILD")
+      }
+    ];
 
-  writePkbuild(pkgbuildFileName) {
-    const out = createWriteStream(pkgbuildFileName, { encoding: "utf8" });
+    await copyEntries(transform(sources, metaTransformers, true), staging);
 
-    out.write(`
-package() {
-   cp -r $srcdir/* "$pkgdir"
-}
-`);
+    await execa("makepkg", ["-f"], { cwd: staging });
 
-    out.end();
+    return join(options.destination, this.packageFileName);
   }
 }
 
@@ -55,18 +107,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: { default: [], 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 +133,13 @@ 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
-  };
-
-  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(
@@ -182,22 +171,8 @@ package() {
 }
 `
   );
-
-  await promisify(finished);
-}
-
-function makeDepends(d) {
-  if (d === undefined) {
-    return [];
-  }
-
-  return Object.keys(d).reduce((a, c) => {
-    const mapping = {
-      node: "nodejs"
-    };
-
-    a.push(`${mapping[c] ? mapping[c] : c}${d[c].replace(/\-([\w\d]+)$/, "")}`);
-    return a;
-  }, []);
-}
 */
+
+const mapping = {
+  node: "nodejs"
+};

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,98 @@ 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",
+      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 +117,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,21 +49,30 @@ export function extractFromPackage(pkg) {
     )[0];
   }
 
+  if (pkg.repository) {
+    properties.source = pkg.repository.url;
+  }
+
+  let dependencies = { ...pkg.engines };
   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 })
       );
     }
+
+    Object.assign(dependencies, pkgbuild.depends);
   }
 
-  return { properties, sources };
+  return { properties, sources, dependencies };
 }
 
 /**
@@ -71,7 +80,7 @@ export function extractFromPackage(pkg) {
  * @param {AsyncIterator<ContentEntry>} source
  * @param {Transformer[]} transformers
  */
-export async function* transform(source, transformers) {
+export async function* transform(source, transformers = [], onlyMatching) {
   const usedTransformers = new Set();
 
   for await (let entry of source) {
@@ -79,10 +88,16 @@ export async function* transform(source, transformers) {
       if (t.match(entry)) {
         entry = await t.transform(entry);
         usedTransformers.add(t);
+
+        if (onlyMatching) {
+          yield entry;
+        }
       }
     }
 
-    yield entry;
+    if (!onlyMatching) {
+      yield entry;
+    }
   }
 
   for (const t of transformers) {
@@ -103,7 +118,7 @@ export async function copyEntries(
   attributes = []
 ) {
   for await (let entry of source) {
-    const destName = join(destinationDirectory, entry.name);
+    const destName = entry.destination === undefined ? join(destinationDirectory, entry.name) : join(destinationDirectory, entry.destination, entry.name);
     await mkdir(dirname(destName), { recursive: true });
 
     const options = { mode: entry.mode };
@@ -114,6 +129,7 @@ export async function copyEntries(
       }
     }
 
+    console.log(destName);
     await pipeline(
       await entry.readStream,
       createWriteStream(destName, options)