pkgs/applications/editors/emacs/elisp-packages/libgenerated.nix

   1 lib: self:
   2
   3 let
   4   inherit (lib) elemAt;
   5
   6   matchForgeRepo = builtins.match "(.+)/(.+)";
   7
   8   fetchers = lib.mapAttrs (_: fetcher: self.callPackage fetcher { }) {
   9     github =
  10       { fetchFromGitHub }:
  11       {
  12         repo ? null,
  13         ...
  14       }:
  15       { sha256, commit, ... }:
  16       let
  17         m = matchForgeRepo repo;
  18       in
  19       assert m != null;
  20       fetchFromGitHub {
  21         owner = elemAt m 0;
  22         repo = elemAt m 1;
  23         rev = commit;
  24         inherit sha256;
  25       };
  26
  27     gitlab =
  28       { fetchFromGitLab }:
  29       {
  30         repo ? null,
  31         ...
  32       }:
  33       { sha256, commit, ... }:
  34       let
  35         m = matchForgeRepo repo;
  36       in
  37       assert m != null;
  38       fetchFromGitLab {
  39         owner = elemAt m 0;
  40         repo = elemAt m 1;
  41         rev = commit;
  42         inherit sha256;
  43       };
  44
  45     git = (
  46       { fetchgit }:
  47       {
  48         url ? null,
  49         ...
  50       }:
  51       { sha256, commit, ... }:
  52       (fetchgit {
  53         rev = commit;
  54         inherit sha256 url;
  55       }).overrideAttrs(_: {
  56         GIT_SSL_NO_VERIFY = true;
  57       })
  58     );
  59
  60     bitbucket =
  61       { fetchhg }:
  62       {
  63         repo ? null,
  64         ...
  65       }:
  66       { sha256, commit, ... }:
  67       fetchhg {
  68         rev = commit;
  69         url = "https://bitbucket.com/${repo}";
  70         inherit sha256;
  71       };
  72
  73     hg =
  74       { fetchhg }:
  75       {
  76         url ? null,
  77         ...
  78       }:
  79       { sha256, commit, ... }:
  80       fetchhg {
  81         rev = commit;
  82         inherit sha256 url;
  83       };
  84
  85     sourcehut =
  86       { fetchzip }:
  87       {
  88         repo ? null,
  89         ...
  90       }:
  91       { sha256, commit, ... }:
  92       fetchzip {
  93         url = "https://git.sr.ht/~${repo}/archive/${commit}.tar.gz";
  94         inherit sha256;
  95       };
  96
  97     codeberg =
  98       { fetchzip }:
  99       {
 100         repo ? null,
 101         ...
 102       }:
 103       { sha256, commit, ... }:
 104       fetchzip {
 105         url = "https://codeberg.org/${repo}/archive/${commit}.tar.gz";
 106         inherit sha256;
 107       };
 108   };
 109
 110 in {
 111
 112   melpaDerivation = variant:
 113                       { ename, fetcher
 114                       , commit ? null
 115                       , sha256 ? null
 116                       , ... }@args:
 117       let
 118         sourceArgs = args.${variant};
 119         version = sourceArgs.version or null;
 120         deps = sourceArgs.deps or null;
 121         error = sourceArgs.error or args.error or null;
 122         hasSource = lib.hasAttr variant args;
 123         pname = builtins.replaceStrings [ "@" ] [ "at" ] ename;
 124         broken = error != null;
 125       in
 126       if hasSource then
 127         lib.nameValuePair ename (
 128           self.callPackage ({ melpaBuild, fetchurl, ... }@pkgargs:
 129           melpaBuild {
 130             inherit pname ename;
 131             inherit (sourceArgs) commit;
 132             version = lib.optionalString (version != null)
 133               (lib.concatStringsSep "." (map toString
 134                 # Hack: Melpa archives contains versions with parse errors such as [ 4 4 -4 413 ] which should be 4.4-413
 135                 # This filter method is still technically wrong, but it's computationally cheap enough and tapers over the issue
 136                 (builtins.filter (n: n >= 0) version)));
 137             # TODO: Broken should not result in src being null (hack to avoid eval errors)
 138             src = if (sha256 == null || broken) then null else
 139               fetchers.${fetcher} args sourceArgs;
 140             recipe = if commit == null then null else
 141               fetchurl {
 142                 name = pname + "-recipe";
 143                 url = "https://raw.githubusercontent.com/melpa/melpa/${commit}/recipes/${ename}";
 144                 inherit sha256;
 145               };
 146             packageRequires = lib.optionals (deps != null)
 147               (map (dep: pkgargs.${dep} or self.${dep} or null)
 148                    deps);
 149             meta = (sourceArgs.meta or {}) // {
 150               inherit broken;
 151             };
 152           }
 153         ) {}
 154       )
 155     else
 156       null;
 157
 158 }