mkPackages: automagically wrapping with hello as a test package

lib/default.nix

@@ -204,39 +204,72 @@ rec {
     /<name> -> packages named by directory
     /<name>/call.nix ->  callPackage override imported via import <file> pkgs
     call.nix example
-      pkgs: {
+      {python3Packages}: {
-        inherit (pkgs.python3Packages) callPackage;
+        inherit (python3Packages) callPackage;
         args = {};
      }
 
     /<name>/package.nix -> the package itself
+    /<name>/wrapper.nix:
+    a optional wrapper for the package
+    which is callPackage'd with the original package
+    as an argument named <name>-unwrapped
   */
   mkPackages =
     path: pkgs:
     lib.pipe path [
       builtins.readDir
       (lib.filterAttrs (_: v: v == "directory"))
-      (lib.mapAttrs (
+      builtins.attrNames
-        n: _:
+      (map (
+        n:
         let
-          callPackage = lib.callPackageWith (
+          p = "${path}/${n}";
-            pkgs
+
-            // {
+          callPackage =
-              inputs = constructInputs' pkgs.system inputs;
+            file: args:
-              # maybe add self?
+            let
-              # inherit self;
+              defaultArgs =
-              # npins sources if i need them
+                pkgs
-              # sources = import ./npins;
+                // (
-            }
+                  let
-          );
+                    inputs' = constructInputs' pkgs.stdenv.system inputs;
+                  in
+                  {
+                    inherit inputs' inputs;
+                    self' = inputs'.self;
+                    inherit (inputs) self;
+                    # npins sources if i ever use them
+                    # sources = lib.mapAttrs (_: pkgs.npins.mkSource) (lib.importJSON "${self}/packages/sources.json").pins;
+                  }
+                );
+              _callPackage = lib.callPackageWith defaultArgs;
+              fullPath = "${p}/${file}.nix";
+              callPath = "${p}/call.nix";
+            in
+            assert lib.assertMsg (builtins.pathExists fullPath)
+              "File attempting to be callPackage'd '${fullPath}' does not exist";
+
+            if builtins.pathExists callPath then
+              let
+                x = _callPackage callPath { };
+              in
+              x.callPackage or _callPackage fullPath (x.args or defaultArgs // args)
+
+            else
+              _callPackage fullPath args;
         in
-        if builtins.pathExists "${path}/${n}/call.nix" then
+
+        if builtins.pathExists "${p}/wrapper.nix" then
+          # My distaste for rec grows ever stronger
           let
-            x = import "${path}/${n}/call.nix" pkgs;
+            set."${n}-unwrapped" = callPackage "package" { };
           in
-          x.callPackage "${path}/${n}/package.nix" x.args
+          { ${n} = callPackage "wrapper" set; } // set
         else
-          callPackage "${path}/${n}/package.nix" { }
+          { ${n} = callPackage "package" { }; }
+
       ))
+      lib.mergeAttrsList
     ];
 }

packages/hello/call.nix

@@ -0,0 +1,7 @@
+{ callPackage }:
+{
+  callPackage = f: x: callPackage f ({ bar = "foo"; } // x);
+  args = {
+    foo = "bar";
+  };
+}

packages/hello/package.nix

@@ -0,0 +1,19 @@
+{
+  stdenv,
+  fetchurl,
+  foo,
+  bar,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "hello";
+  version = "2.12.1";
+
+  src = fetchurl {
+    url = "mirror://gnu/hello/hello-${finalAttrs.version}.tar.gz";
+    hash = "sha256-jZkUKv2SV28wsM18tCqNxoCZmLxdYH2Idh9RLibH2yA=";
+  };
+  passthru = {
+    inherit foo bar;
+  };
+})

packages/hello/wrapper.nix

@@ -0,0 +1,17 @@
+{
+  symlinkJoin,
+  foo,
+  bar,
+  hello-unwrapped,
+}:
+symlinkJoin {
+  name = "hello-wrapped";
+  paths = [ hello-unwrapped ];
+  postBuild = ''
+    ln -s $out/bin/hello $out/bin/hello-wrapped
+  '';
+
+  passthru = {
+    inherit foo bar;
+  };
+}