bulk versions.json

lib/versioning.nix

@@ -0,0 +1,181 @@
+{ lib, pkgs }:
+
+let
+  inherit (builtins)
+    isAttrs
+    isList
+    isString
+    hasAttr
+    getAttr
+    attrNames
+    toString
+    replaceStrings;
+
+  mapAttrs = lib.mapAttrs;
+  recursiveUpdate = lib.recursiveUpdate;
+
+  # Deep-merge attrsets (right-biased).
+  deepMerge = a: b: recursiveUpdate a b;
+
+  # Merge component sources: base.sources overlaid by overrides (component-wise deep merge).
+  mergeSources = baseSources: overrides:
+    baseSources //
+    mapAttrs (name: ov:
+      if hasAttr name baseSources then deepMerge (getAttr name baseSources) ov else ov
+    ) overrides;
+
+  # Apply a single variant overlay (variables + sources).
+  applyVariantOnce = selected: variant:
+    let
+      vVars = if variant ? variables then variant.variables else {};
+      vSrcs = if variant ? sources then variant.sources else {};
+    in
+    {
+      variables = selected.variables // vVars;
+      sources   = mergeSources selected.sources vSrcs;
+    };
+
+  # Apply platform-specific overrides if present for the given system.
+  applyPlatforms = selected: variant: system:
+    if system == null || !(variant ? platforms) || !(hasAttr system variant.platforms) then
+      selected
+    else
+      let
+        p = variant.platforms.${system};
+        pVars = if p ? variables then p.variables else {};
+        pSrcs = if p ? sources then p.sources else {};
+      in
+      {
+        variables = selected.variables // pVars;
+        sources   = mergeSources selected.sources pSrcs;
+      };
+
+  # Resolve variant chain via inherits (ancestor first), then apply platforms.
+  resolveVariant = spec: baseSelected: variantName: system:
+    if variantName == null || !(spec ? variants) || !(hasAttr variantName spec.variants) then
+      baseSelected
+    else
+      let
+        v = spec.variants.${variantName};
+        parentSelected =
+          if v ? inherits then resolveVariant spec baseSelected v.inherits system else baseSelected;
+        withVariant = applyVariantOnce parentSelected v;
+      in
+      applyPlatforms withVariant v system;
+
+  # Render ${var} substitutions in any string within attrs/lists.
+  renderValue = value: vars:
+    if isString value then
+      let
+        keys = attrNames vars;
+        patterns = map (k: "\${" + k + "}") keys;
+        replacements = map (k: toString (getAttr k vars)) keys;
+      in
+      replaceStrings patterns replacements value
+    else if isAttrs value then
+      mapAttrs (_: v: renderValue v vars) value
+    else if isList value then
+      map (v: renderValue v vars) value
+    else
+      value;
+
+  # Decide fetcher for URL type based on optional extra.unpack hint.
+  useFetchZip = comp:
+    comp ? extra && comp.extra ? unpack && comp.extra.unpack == "zip";
+
+  # Build a single src from a rendered component spec.
+  mkSrcFromRendered = comp:
+    let
+      fetcher = if comp ? fetcher then comp.fetcher else "none";
+    in
+    if fetcher == "github" then
+      pkgs.fetchFromGitHub ({
+        owner = comp.owner;
+        repo  = comp.repo;
+        # Allow tag as rev (ignore null/empty tag)
+        rev   = if comp ? tag && comp.tag != null && comp.tag != "" then comp.tag else comp.rev;
+        fetchSubmodules = if comp ? submodules then comp.submodules else false;
+        hash = comp.hash;
+      } // lib.optionalAttrs (comp ? name) { name = comp.name; })
+    else if fetcher == "git" then
+      pkgs.fetchgit {
+        url = comp.url;
+        rev = comp.rev;
+        fetchSubmodules = if comp ? submodules then comp.submodules else false;
+        hash = comp.hash;
+      }
+    else if fetcher == "url" then
+      let
+        url = if comp ? url then comp.url else comp.urlTemplate;
+      in
+      if useFetchZip comp then
+        pkgs.fetchzip (
+          { inherit url; hash = comp.hash; }
+          // lib.optionalAttrs (comp ? extra && comp.extra ? stripRoot) { stripRoot = comp.extra.stripRoot; }
+        )
+      else
+        pkgs.fetchurl { inherit url; hash = comp.hash; }
+    else if fetcher == "pypi" then
+      pkgs.python3Packages.fetchPypi {
+        pname = comp.name;
+        version = comp.version;
+        hash = comp.hash;
+      }
+    else
+      # fetcher == "none": pass-through (e.g., linux version/hash consumed by custom logic)
+      comp;
+
+in rec {
+  /*
+    Select a variant from a loaded version.json specification.
+
+    Usage:
+      let selected = versioning.selectVariant spec variantName system;
+      - spec: attrset from lib.importJSON ./version.json
+      - variantName: string or null (when null, uses spec.defaultVariant if present)
+      - system: string like "x86_64-linux" or null (to apply platforms overrides)
+  */
+  selectVariant = spec: variantName: system:
+    let
+      chosen = if variantName != null then variantName else (if spec ? defaultVariant then spec.defaultVariant else null);
+      baseSelected = {
+        variables = if spec ? variables then spec.variables else {};
+        sources   = if spec ? sources then spec.sources else {};
+      };
+    in
+    resolveVariant spec baseSelected chosen system;
+
+  /*
+    Render ${var} template substitutions across any value using provided variables.
+    Strings, attrsets, and lists are traversed.
+  */
+  render = value: variables: renderValue value variables;
+
+  /*
+    Render a component with variables and then build its src (or pass-through for fetcher "none").
+    Prefer using mkAllSources, which handles rendering for all components.
+  */
+  mkSrc = comp: variables:
+    let rendered = renderValue comp variables;
+    in mkSrcFromRendered rendered;
+
+  /*
+    Produce an attrset of all sources for a selected spec:
+      mkAllSources selected
+    Where:
+      selected = selectVariant spec variantName system
+    Returns:
+      { componentName = src | renderedComp (for "none"); ... }
+  */
+  mkAllSources = selected:
+    mapAttrs (_name: comp:
+      if comp ? fetcher && comp.fetcher == "none"
+      then renderValue comp selected.variables
+      else mkSrc (renderValue comp selected.variables) selected.variables
+    ) selected.sources;
+
+  /*
+    Expose deepMerge for convenience (right-biased).
+  */
+  inherit deepMerge;
+}