homeManager use under the new dependency system

[Cybolic]

I'm probably missing something really simple, but how does the homeManager attribute fit into the new dependency system?

I assumed the following would work, but it doesn't seem like the homeManager attribute is parsed for user-to-host aspects.

  pro.test-user._.test-host =
    { toHost, fromUser }:
    {
      includes = [
        {
          nixos =
            { pkgs, ... }:
            {
              users.users.${fromUser.name}.packages = [ pkgs.hello ];
            };
          homeManager =
            { pkgs, ... }:
            {
              home.packages = [ pkgs.gnugrep ];
            };
        }
      ];
    };

(full test in this branch: https://github.com/Cybolic/nix-den-double-import-demo/blob/home-manager/modules/hosts.nix)

Also, minor thing - and I get why it doesn't work with the new signatures for the dependencies - but it would be nice to be able to do a short-form include - just as a convenience:

  pro.test-user._.test-host.includes = [
    {
      nixos =
        { pkgs, ... }:
        {
          environment.systemPackages = [ pkgs.hello ];
        };
    }
  ];

[Cybolic]

I figured it out (thanks to looking at dependencies.nix).
The "direction" of the "provides" needs to be reversed for this case.

So, this won't work:
pro.test-user._.test-host = { fromUser, toHost }: { homeManager = ... }

But this will:
pro.test-host._.test-user = { fromHost, toUser }: { homeManager = ... }

[vic]

Since users only exist inside a host, why not just have something like:

den.provides.user = aspect: param: {
  # pretty much the same way dependencies.nix works:
  __functor = den.lib.parametric param;
  includes = [
    ({ fromUser, toHost }: den.lib.owned toHost.class aspect)
    ({ fromHost, toUser }: den.lib.owned toUser.class aspect)  
  ];
}

# Usage would be:
{
  __functor = den._.user;
  homeManager = ...;
  nixos = ...;
}

maybe you can try something like this? I haven't tried the code, so you might need to adapt it.

[vic]

Also I think I will move to simpler direction contexts, instead of { fromUser, toHost } -> { userToHost } and we could access userToHost.user and userToHost.host (similarly a { hostToUser }).

This change would help in situations where you don't need to use both arguments, like my examples above, only use toHost and not fromUser, and I have to use # deadnix: skip so my nix linter knows it cannot remove the fromUser argument, because if it is removed the context will never match!, so I dont need formatters causing problems because of unused vars.

[Cybolic]

The way I'm doing it right now is more brute-force -ish:

user-provides-shared-config-to-host = { fromUser, toHost }:
  (pro.${fromUser.aspect}._."__${toHost.aspect}" or noop) { inherit fromUser toHost; };
user-provides-shared-config-to-user = { fromHost, toUser }:
  (pro.${toUser.aspect}._."__${fromHost.aspect}" or noop) { fromUser = toUser; toHost = fromHost; };
host-provides-shared-config-to-host = { fromHost, toUser }:
  (pro.${fromHost.aspect}._."__${toUser.aspect}" or noop) { inherit fromHost toUser; };
host-provides-shared-config-to-user = { fromUser, toHost }:
  (pro.${toHost.aspect}._."__${fromUser.aspect}" or noop) { fromHost = toHost; toUser = fromUser; };
  
den.aspects.routes.__functor = den.lib.parametric true;
den.aspects.routes.includes = [
  user-provides-host-config
  host-provides-user-config
  user-provides-shared-config-to-host
  user-provides-shared-config-to-user
  host-provides-shared-config-to-host
  host-provides-shared-config-to-user
];

But this way also allows for setups like this:

pro.cybolic._.__desktop-pc = { fromUser, toHost }: {
  includes = [
    pro.cybolic._.music-making
    pro.cybolic._.video-editing
  ];
  nixos = { pkgs, ... }: {
    hardware.graphics.extraPackages = [ pkgs.mesa.opencl ];
  };
};

[vic]

Just merged #54

You can try something like:

let
  locate = from: into: pro.${from.aspect}._.${into.aspect} or noop;
  route = locate: { user, host }@ctx: (locate user host) ctx;
in
den.aspects.routes.include = [
  ({ userToHost, ...}: route locate userToHost)
  ({ hostToUser, ...}: route (lib.flip locate) hostToUser)
]

and

pro.cybolic._.desktop-pc = { user, host }: { ... };

[vic]

This is how the route example looks now. Also being tested now in CI.