npm-pkgbuild 7.15.4 → 7.15.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.15.4",
+  "version": "7.15.8",
   "publishConfig": {
     "access": "public"
   },
@@ -40,12 +40,12 @@
   "dependencies": {
     "aggregate-async-iterator": "^1.1.7",
     "commander": "^8.3.0",
-    "content-entry": "^4.0.0",
-    "content-entry-filesystem": "^4.0.0",
-    "content-entry-transform": "^1.3.1",
+    "content-entry": "^4.1.2",
+    "content-entry-filesystem": "^4.0.3",
+    "content-entry-transform": "^1.3.4",
     "execa": "^6.0.0",
     "expression-expander": "^7.0.9",
-    "globby": "^12.0.2",
+    "globby": "^12.2.0",
     "iterable-string-interceptor": "^1.0.8",
     "key-value-transformer": "^2.0.0",
     "npm-package-walker": "^5.0.3",

package/src/extract-from-package.mjs

@@ -11,9 +11,9 @@ export const allInputs = [NPMPackContentProvider, NodeModulesContentProvider];
 export const allOutputs = [DEB, ARCH, RPM];
 
 const npmArchMapping = {
-	"arm64" : "aarch64",
-	"arm": "armv7h",
-	"x86" : "x86_64"
+  arm64: "aarch64",
+  arm: "armv7h",
+  x86: "x86_64"
 };
 
 /**
@@ -48,10 +48,9 @@ export async function extractFromPackage(pkg, dir) {
   }
 
   if (pkg.repository) {
-    if(typeof(pkg.repository) === 'string') {
+    if (typeof pkg.repository === "string") {
       properties.source = pkg.repository;
-    }
-    else {
+    } else {
       if (pkg.repository.url) {
         properties.source = pkg.repository.url;
       }
@@ -62,24 +61,23 @@ export async function extractFromPackage(pkg, dir) {
   let sources = [];
   let output = {};
   let arch = new Set();
-  
-  const processPkg = (pkg, dir) => {
 
-    if(pkg.cpu) {
-      for(const a of asArray(pkg.cpu)) {
+  const processPkg = (pkg, dir) => {
+    if (pkg.cpu) {
+      for (const a of asArray(pkg.cpu)) {
         arch.add(npmArchMapping[a]);
       }
-    } 
+    }
 
     if (pkg.pkg) {
       const pkgbuild = pkg.pkg;
 
-      if(pkgbuild.arch) {
-        for(const a of asArray(pkgbuild.arch)) {
+      if (pkgbuild.arch) {
+        for (const a of asArray(pkgbuild.arch)) {
           arch.add(a);
         }
       }
-      
+
       Object.assign(output, pkgbuild.output);
 
       Object.entries(pkgbuild)
@@ -123,9 +121,9 @@ export async function extractFromPackage(pkg, dir) {
 
   processPkg(pkg, dir);
 
-  if(arch.size > 0) {
+  if (arch.size > 0) {
     properties.arch = [...arch];
   }
-  
+
   return { properties, sources, dependencies, output };
 }

package/src/npm-pkgbuild-cli.mjs

@@ -83,6 +83,15 @@ program
       )) {
         Object.assign(properties, options.define);
 
+        for (const [k, v] of Object.entries(properties)) {
+          if (typeof v === "string") {
+            properties[k] = v.replace(
+              /\$\{([^\}]+)\}/m,
+              (m, k) => properties[k]
+            );
+          }
+        }
+
         sources.push(
           ...[...options.content, ...options.meta]
             .filter(x => x)

package/src/output/arch.mjs

@@ -43,6 +43,9 @@ function keyPrefix(key) {
   return f && f.prefix ? f.prefix + key : key;
 }
 
+
+const PKGBUILD = "PKGBUILD";
+
 export class ARCH extends Packager {
   static get name() {
     return "arch";
@@ -108,8 +111,8 @@ package() {
     const fp = fieldProvider(properties, fields);
 
     transformer.push({
-      name: "PKGBUILD",
-      match: entry => entry.name === "PKGBUILD",
+      name: PKGBUILD,
+      match: entry => entry.name === PKGBUILD,
       transform: async entry =>
         new ReadableStreamContentEntry(
           "../" + entry.name,
@@ -118,7 +121,7 @@ package() {
             trailingLines
           })
         ),
-      createEntryWhenMissing: () => new EmptyContentEntry("PKGBUILD")
+      createEntryWhenMissing: () => new EmptyContentEntry(PKGBUILD)
     });
 
     for await (const file of copyEntries(

package/src/util.mjs

@@ -2,11 +2,56 @@ 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 { ReadableStreamContentEntry } from "content-entry";
 
 export const utf8StreamOptions = { encoding: "utf8" };
 
+/**
+ * Extract shell functions from a given text
+ * @param {AsyncIterator<string>} source
+ * @return {AsyncIterator<FunctionDecl>}
+ */
+export async function* extractFunctions(source) {
+  let name;
+  let body = [];
+
+  for await (const line of asLines(source)) {
+    let m;
+
+    if ((m = line.match(/^\s*(function\s*)?([\w_]+)\s*\(\s*\)/))) {
+      name = m[2];
+      continue;
+    }
+
+    if (name) {
+      if (line.match(/^}$/)) {
+        yield { name, body: body.join("\n")};
+        name = undefined;
+        body.length = 0;
+      }
+      else {
+        body.push(line);
+      }
+    }
+  }
+}
+
+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;
+  }
+}
+
 export function quote(v) {
   if (v === undefined) return "";