lab-infra/lib/nix-patches/default.nix

# Copyright Tom Hubrecht, (2023-2024)
#
# Tom Hubrecht <tom@hubrecht.ovh>
#
# This software is governed by the CeCILL  license under French law and
# abiding by the rules of distribution of free software.  You can  use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and  rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty  and the software's author,  the holder of the
# economic rights,  and the successive licensors  have only  limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading,  using,  modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean  that it is complicated to manipulate,  and  that  also
# therefore means  that it is reserved for developers  and  experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and,  more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.

{
  patchFile,
  excludeGitHubManual ? true,
  fetchers ? { },
}:

rec {
  base =
    { pkgs }:
    rec {
      mkUrlPatch =
        attrs:
        pkgs.fetchpatch (
          {
            hash = pkgs.lib.fakeHash;
          }
          // attrs
          // (pkgs.lib.optionalAttrs (excludeGitHubManual && !(builtins.hasAttr "includes" attrs)) {
            excludes = (attrs.excludes or [ ]) ++ [ "nixos/doc/manual/*" ];
          })
        );

      mkGitHubPatch =
        { id, ... }@attrs:
        mkUrlPatch (
          (builtins.removeAttrs attrs [ "id" ])
          // {
            url = "https://github.com/NixOS/nixpkgs/pull/${builtins.toString id}.diff";
          }
        );

      mkCommitPatch =
        { sha, ... }@attrs:
        mkUrlPatch (
          (builtins.removeAttrs attrs [ "sha" ])
          // {
            url = "https://github.com/NixOS/nixpkgs/commit/${builtins.toString sha}.diff";
          }
        );

      patchFunctions = {
        commit = mkCommitPatch;
        github = mkGitHubPatch;
        remote = pkgs.fetchpatch;
        static = attrs: attrs.path;
        url = mkUrlPatch;
      } // fetchers;

      mkPatch =
        {
          _type ? "github",
          ...
        }@attrs:
        if builtins.hasAttr _type patchFunctions then
          patchFunctions.${_type} (builtins.removeAttrs attrs [ "_type" ])
        else
          throw "Unknown patch type: ${builtins.toString _type}.";

      mkPatches = v: builtins.map mkPatch ((import patchFile).${v} or [ ]);

      applyPatches =
        {
          src,
          name,
          patches ? mkPatches name,
        }:
        if patches == [ ] then
          src
        else
          pkgs.applyPatches {
            inherit patches src;

            name = "${name}-patched";
          };

      applyPatches' = name: src: applyPatches { inherit name src; };
    };

  mkNixpkgsSrc = { src, name }: (base { pkgs = import src { }; }).applyPatches { inherit src name; };
}