add fenix.{fromManifest,fromManifestFile,toolchainOf}

rewrite stable and beta toolchains
close #16

Author: figsoda

.github/workflows/update.yml

@@ -25,17 +25,16 @@ jobs:
           git config --local user.email "[email protected]"
 
           nix-shell --run ./update -p "python3.withPackages (ps: [ ps.toml ])"
-          if [ -n "$(git diff)" ]; then
-            git commit -am "update toolchains"
-          fi
 
-          nix flake update --commit-lock-file
+          nix flake update
+
+          curl -fLSso data/stable.toml https://static.rust-lang.org/dist/channel-rust-stable.toml
+          curl -fLSso data/beta.toml https://static.rust-lang.org/dist/channel-rust-beta.toml
 
           curl -fLSso data/rust-analyzer-vsix.zip \
             https://github.com/rust-analyzer/rust-analyzer/releases/download/nightly/rust-analyzer.vsix || true
-          if [ -n "$(git diff)" ]; then
-            git commit -am "update rust analyzer vscode extension"
-          fi
+
+          git commit -am "update rust analyzer vscode extension"
 
       - name: Push changes
         uses: ad-m/github-push-action@master

README.md

@@ -35,6 +35,10 @@ As a flake (recommended)
     # fenix.packages.x86_64-linux.minimal.toolchain
     # fenix.packages.x86_64-linux.stable.defaultToolchain
     # fenix.packages.x86_64-linux.beta.completeToolchain
+    # fenix.packages.x86_64-linux.fromManifest (import ./channel-rust-nightly.nix)
+    # fenix.packages.x86_64-apple-darwin.fromManifestFile ./channel-rust-stable.toml
+    # fenix.packages.aarch64-linux.toolchainOf { date = "2021-07-01"; sha256 = ""; }
+    # fenix.packages.x86_64-linux.toolchainOf { channel = "stable"; date = "2021-06-17"; sha256 = ""; }
     # fenix.packages.x86_64-linux.targets.aarch64-unknown-linux-gnu.latest.rust-std
     # fenix.packages.x86_64-linux.targets.wasm32-unknown-unknown.stable.rust-std
     # fenix.packages.x86_64-linux.rust-analyzer

data/beta.json

@@ -21,36 +21,69 @@
       mapAttrs (k: v:
         let
           pkgs = nixpkgs.legacyPackages.${k};
+
           mkToolchain = pkgs.callPackage ./lib/mk-toolchain.nix { };
+
           nightlyToolchains = mapAttrs
             (_: mapAttrs (profile: mkToolchain "rust-nightly-${profile}"))
             (fromJSON (readFile ./data/nightly.json));
+
+          fromManifest' = target: name: manifest:
+            let
+              toolchain = mkToolchain name {
+                inherit (manifest) date;
+                components = mapAttrs (_: src: {
+                  inherit (src) url;
+                  sha256 = src.hash;
+                }) (filterAttrs (_: src: src ? available && src.available)
+                  (mapAttrs (component: pkg:
+                    if pkg.target ? "*" then
+                      pkg.target."*"
+                    else if pkg.target ? ${target} then
+                      pkg.target.${target}
+                    else
+                      null) manifest.pkg));
+              };
+            in toolchain // mapAttrs' (k: v:
+              nameValuePair "${k}Toolchain" (toolchain.withComponents
+                (filter (component: toolchain ? ${component}) v)))
+            manifest.profiles;
+
+          fromManifestFile' = target: name: file:
+            fromManifest' target name (fromTOML (readFile file));
+
+          toolchainOf' = target:
+            { root ? "https://static.rust-lang.org/dist", channel ? "nightly"
+            , date, sha256 }:
+            fromManifestFile' target "rust-${channel}" (fetchurl {
+              inherit sha256;
+              url = "${root}/${date}/channel-rust-${channel}.toml";
+            });
+
           mkToolchains = channel:
-            let manifest = fromJSON (readFile (./data + "/${channel}.json"));
-            in mapAttrs (_: components:
-              let
-                toolchain = mkToolchain "rust-${channel}" {
-                  inherit (manifest) date;
-                  inherit components;
-                };
-              in toolchain // mapAttrs' (k: v:
-                nameValuePair "${k}Toolchain" (toolchain.withComponents
-                  (filter (component: hasAttr component toolchain) v)))
-              manifest.profiles) manifest.targets;
-          stableToolchains = mkToolchains "stable";
-          betaToolchains = mkToolchains "beta";
+            let manifest = fromTOML (readFile (./data + "/${channel}.toml"));
+            in mapAttrs (target: _: {
+              ${channel} = fromManifest' target "rust-${channel}" manifest;
+            }) manifest.pkg.rust-std.target;
+
           rust-analyzer-rev = substring 0 7 (fromJSON
             (readFile ./flake.lock)).nodes.rust-analyzer-src.locked.rev;
         in nightlyToolchains.${v} // rec {
           combine = pkgs.callPackage ./lib/combine.nix { } "rust-mixed";
 
-          stable = stableToolchains.${v};
+          fromManifest = fromManifest' v "rust";
+
+          fromManifestFile = fromManifestFile' v "rust";
+
+          toolchainOf = toolchainOf' v;
+
+          stable = fromManifestFile' v "rust-stable" ./data/stable.toml;
 
-          beta = betaToolchains.${v};
+          beta = fromManifestFile' v "rust-beta" ./data/beta.toml;
 
           targets = zipAttrsWith (_: foldl (x: y: x // y) { }) [
-            (mapAttrs (_: toolchain: { stable = toolchain; }) stableToolchains)
-            (mapAttrs (_: toolchain: { beta = toolchain; }) betaToolchains)
+            (mkToolchains "stable")
+            (mkToolchains "beta")
             nightlyToolchains
           ];
 

data/beta.toml

@@ -153,34 +153,3 @@ def fetch_nightly(d = None):
 
 fetch_nightly()
 json.dump(nightly, open("data/nightly.json", "w"))
-
-for channel in ["stable", "beta"]:
-    resp = urlopen(f"{dist_root}/channel-rust-{channel}.toml")
-    manifest = toml.loads(resp.read().decode("utf-8"))
-    results = {
-        "date": manifest["date"],
-        "targets": { target: {} for target in targets },
-        "profiles": { profile: manifest["profiles"][profile] for profile in profiles },
-    }
-    pkgs = manifest["pkg"]
-
-    for component, pkg in pkgs.items():
-        pkg = pkg["target"]
-        for target in targets:
-            src = pkg.get("*") or pkg.get(target)
-            if src and src["available"]:
-                results["targets"][target][component] = {
-                    "url": src["url"],
-                    "sha256": src["hash"],
-                }
-
-    for target, src in pkgs["rust-std"]["target"].items():
-        if src["available"] and not target in targets:
-            results["targets"][target] = {
-                "rust-std": {
-                    "url": src["url"],
-                    "sha256": src["hash"],
-                },
-            }
-
-    json.dump(results, open(f"data/{channel}.json", "w"))