uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>

pkgs/development/web/deno/update/common.ts

@@ -0,0 +1,55 @@
+interface GHRelease {
+  tag_name: string;
+}
+
+const decode = (buffer: Uint8Array) => new TextDecoder("utf-8").decode(buffer);
+const decodeTrim = (b: Uint8Array) => decode(b).trimEnd();
+export const run = async (command: string, args: string[]) => {
+  const cmd = Deno.run({
+    cmd: [command, ...args],
+    stdout: "piped",
+    stderr: "piped",
+  });
+  if (!(await cmd.status()).success) {
+    const error = await cmd.stderrOutput().then(decodeTrim);
+    // Known error we can ignore
+    if (error.includes("'allow-unsafe-native-code-during-evaluation'")) {
+      // Extract the target sha256 out of the error
+      const target = "  got:    sha256:";
+      const match = error
+        .split("\n")
+        .find((l) => l.includes(target))
+        ?.split(target)[1];
+      if (typeof match !== "undefined") {
+        return match;
+      }
+    }
+    throw new Error(error);
+  }
+  return cmd.output().then(decodeTrim);
+};
+
+// Exports
+export const versionRegExp = /\d+\.\d+\.\d+/;
+export const sha256RegExp = /[a-z0-9]{52}|sha256-.{44}/;
+
+export const getExistingVersion = async (filePath: string) =>
+  read(filePath).then(
+    (s) => s.match(genValueRegExp("version", versionRegExp))?.shift() || "",
+  );
+
+export const getLatestVersion = (owner: string, repo: string) =>
+  fetch(`https://api.github.com/repos/${owner}/${repo}/releases`)
+    .then((res) => res.json())
+    .then((res: GHRelease[]) => res[0].tag_name);
+
+// The (?<=) and (?=) allow replace to only change inside
+// Match the regex passed in or empty
+export const genValueRegExp = (key: string, regex: RegExp) =>
+  new RegExp(`(?<=${key} = ")(${regex.source}|)(?=")`);
+
+export const logger = (name: string) =>
+  (...a: any) => console.log(`[${name}]`, ...a);
+
+export const read = Deno.readTextFile;
+export const write = Deno.writeTextFile;

pkgs/development/web/deno/update/librusty_v8.ts

@@ -0,0 +1,90 @@
+import {
+  genValueRegExp,
+  getExistingVersion,
+  logger,
+  run,
+  versionRegExp,
+  write,
+} from "./common.ts";
+
+const log = logger("librusty_v8");
+
+export interface Architecture {
+  nix: string;
+  rust: string;
+}
+interface PrefetchResult {
+  arch: Architecture;
+  sha256: string;
+}
+
+const getLibrustyV8Version = async (
+  owner: string,
+  repo: string,
+  version: string,
+) =>
+  fetch(`https://github.com/${owner}/${repo}/raw/${version}/core/Cargo.toml`)
+    .then((res) => res.text())
+    .then((txt) => txt.match(genValueRegExp("v8", versionRegExp))?.shift());
+
+const fetchArchShaTasks = (version: string, arches: Architecture[]) =>
+  arches.map(
+    async (arch: Architecture): Promise<PrefetchResult> => {
+      log("Fetching:", arch.nix);
+      const sha256 = await run("nix-prefetch", [
+        `
+{ fetchurl }:
+fetchurl {
+  url = "https://github.com/denoland/rusty_v8/releases/download/v${version}/librusty_v8_release_${arch.rust}.a";
+}
+`,
+      ]);
+      log("Done:    ", arch.nix);
+      return { arch, sha256 };
+    },
+  );
+
+const templateDeps = (version: string, deps: PrefetchResult[]) =>
+  `# auto-generated file -- DO NOT EDIT!
+{ rust, stdenv, fetchurl }:
+
+let
+  arch = rust.toRustTarget stdenv.hostPlatform;
+  fetch_librusty_v8 = args: fetchurl {
+    name = "librusty_v8-\${args.version}";
+    url = "https://github.com/denoland/rusty_v8/releases/download/v\${args.version}/librusty_v8_release_\${arch}.a";
+    sha256 = args.shas.\${stdenv.hostPlatform.system};
+    meta = { inherit (args) version; };
+  };
+in
+fetch_librusty_v8 {
+  version = "${version}";
+  shas = {
+${deps.map(({ arch, sha256 }) => `    ${arch.nix} = "${sha256}";`).join("\n")}
+  };
+}
+`;
+
+export async function updateLibrustyV8(
+  filePath: string,
+  owner: string,
+  repo: string,
+  denoVersion: string,
+  arches: Architecture[],
+) {
+  log("Starting librusty_v8 update");
+  // 0.0.0
+  const version = await getLibrustyV8Version(owner, repo, denoVersion);
+  if (typeof version !== "string") {
+    throw "no librusty_v8 version";
+  }
+  log("librusty_v8 version:", version);
+  const existingVersion = await getExistingVersion(filePath);
+  if (version === existingVersion) {
+    log("Version already matches latest, skipping...");
+    return;
+  }
+  const archShaResults = await Promise.all(fetchArchShaTasks(version, arches));
+  await write(filePath, templateDeps(version, archShaResults));
+  log("Finished deps update");
+}

pkgs/development/web/deno/update/src.ts

@@ -0,0 +1,67 @@
+import {
+  genValueRegExp,
+  logger,
+  read,
+  run,
+  sha256RegExp,
+  versionRegExp,
+  write,
+} from "./common.ts";
+
+interface Replacer {
+  regex: RegExp;
+  value: string;
+}
+
+const log = logger("src");
+
+const prefetchSha256 = (nixpkgs: string, version: string) =>
+  run("nix-prefetch", ["-f", nixpkgs, "deno.src", "--rev", version]);
+const prefetchCargoSha256 = (nixpkgs: string) =>
+  run(
+    "nix-prefetch",
+    [`{ sha256 }: (import ${nixpkgs} {}).deno.cargoDeps.overrideAttrs (_: { inherit sha256; })`],
+  );
+
+const replace = (str: string, replacers: Replacer[]) =>
+  replacers.reduce(
+    (str, r) => str.replace(r.regex, r.value),
+    str,
+  );
+
+const updateNix = (filePath: string, replacers: Replacer[]) =>
+  read(filePath).then((str) => write(filePath, replace(str, replacers)));
+
+const genVerReplacer = (k: string, value: string): Replacer => (
+  { regex: genValueRegExp(k, versionRegExp), value }
+);
+const genShaReplacer = (k: string, value: string): Replacer => (
+  { regex: genValueRegExp(k, sha256RegExp), value }
+);
+
+export async function updateSrc(
+  filePath: string,
+  nixpkgs: string,
+  denoVersion: string,
+) {
+  log("Starting src update");
+  const trimVersion = denoVersion.substr(1);
+  log("Fetching sha256 for:", trimVersion);
+  const sha256 = await prefetchSha256(nixpkgs, denoVersion);
+  log("sha256 to update:", sha256);
+  await updateNix(
+    filePath,
+    [
+      genVerReplacer("version", trimVersion),
+      genShaReplacer("sha256", sha256),
+    ],
+  );
+  log("Fetching cargoSha256 for:", sha256);
+  const cargoSha256 = await prefetchCargoSha256(nixpkgs);
+  log("cargoSha256 to update:", cargoSha256);
+  await updateNix(
+    filePath,
+    [genShaReplacer("cargoSha256", cargoSha256)],
+  );
+  log("Finished src update");
+}

pkgs/development/web/deno/update/update.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env nix-shell
+/*
+#!nix-shell -i "deno run --allow-net --allow-run --allow-read --allow-write" -p deno git nix-prefetch
+*/
+import { getExistingVersion, getLatestVersion, logger } from "./common.ts";
+import { Architecture, updateLibrustyV8 } from "./librusty_v8.ts";
+import { updateSrc } from "./src.ts";
+
+const log = logger("update");
+// TODO: Getting current file position to more-safely point to nixpkgs root
+const nixpkgs = Deno.cwd();
+// TODO: Read values from default.nix
+const owner = "denoland";
+const repo = "deno";
+const denoDir = `${nixpkgs}/pkgs/development/web/${repo}`;
+const src = `${denoDir}/default.nix`;
+const librusty_v8 = `${denoDir}/librusty_v8.nix`;
+const architectures: Architecture[] = [
+  { nix: "x86_64-linux", rust: "x86_64-unknown-linux-gnu" },
+  { nix: "aarch64-linux", rust: "aarch64-unknown-linux-gnu" },
+  { nix: "x86_64-darwin", rust: "x86_64-apple-darwin" },
+  { nix: "aarch64-darwin", rust: "aarch64-apple-darwin" },
+];
+
+log("Updating deno");
+
+log("Getting latest deno version");
+const version = await getLatestVersion(owner, repo);
+const existingVersion = await getExistingVersion(src);
+const trimVersion = version.substr(1); // Strip v from v0.0.0
+log("Latest version:   ", trimVersion);
+log("Extracted version:", existingVersion);
+if (trimVersion === existingVersion) {
+  log("Version already matches latest, skipping...");
+  Deno.exit(0);
+}
+
+const tasks = [
+  updateSrc(src, nixpkgs, version),
+  updateLibrustyV8(librusty_v8, owner, repo, version, architectures),
+];
+await Promise.all(tasks);
+log("Updating deno complete");