Question: using the example flake w/ home manager

[flpvsk]

Hello, I am able to run the example flake, but can't figure out how to integrate it into an existing setup with home manager. My config is esentially this template with slight changes: https://github.com/dustinlyons/nixos-config/tree/main/templates/starter

The way I understand it, I'd need to

• Copy the example flake directory somewhere within the nix configuration dir;
• Import the flake by path and use one of the flake's outputs in home manager.

Is that the case?

Disclaimer:

Sorry, I'm new to nix, I've read through the docs and tried a few things but no luck.

Also, if GH is not the place to ask these kind of noob questions, please feel free to close the issue.

[BirdeeHub]

nixCats is this function

Anywhere you can call it with the correct arguments will work.

Compare the useages of that function in the example template with the other ones below it:

nixCats-nvim/templates/example/flake.nix

Lines 471 to 477 in 16ac328

	nixCatsBuilder = utils.baseBuilder luaPath {
	# we pass in the things to make a pkgs variable to build nvim with later
	inherit nixpkgs system dependencyOverlays extra_pkg_config;
	# and also our categoryDefinitions and packageDefinitions
	} categoryDefinitions packageDefinitions;
	# call it with our defaultPackageName
	defaultPackage = nixCatsBuilder defaultPackageName;

nixCats-nvim/templates/example/flake.nix

Line 491 in 16ac328

packages = utils.mkAllWithDefault defaultPackage;

This one shows returning the same outputs, but as a function you can call instead of being an entire flake:

nixCats-nvim/templates/nixExpressionFlakeOutputs/default.nix

Lines 142 to 145 in 16ac328

	nixCatsBuilder = utils.baseBuilder luaPath {
	inherit system dependencyOverlays extra_pkg_config nixpkgs;
	} categoryDefinitions packageDefinitions;
	defaultPackage = nixCatsBuilder defaultPackageName;

nixCats-nvim/templates/nixExpressionFlakeOutputs/default.nix

Line 153 in 16ac328

packages = utils.mkAllWithDefault defaultPackage;

make one of the packages (you can make the others using it later)

nixCats-nvim/templates/flakeless/default.nix

Line 121 in 16ac328

in utils.baseBuilder luaPath { inherit pkgs; } categoryDefinitions packageDefinitions defaultPackageName

Hopefully, seeing how each of these templates works the same way, you provide the same arguments, and call it to receive a package which can be used to build all of the ones in packageDefinitions if desired, you are able to adapt the example template to be callable within your config directly without it being a separate flake!

The special "name the input plugins-pluginname and get pkgs.neovimPlugins.pluginname" is the only other thing to think about, that is simply this function which provided inputs as an argument from within the template's overlays list

In addition, you could use the module instead, but the module for nixCats simply wraps the normal function, and it changes a few of the options slightly, this is honestly probably easier to follow.

If it is not enough, you can ask more questions here about it.

BTW questions in the future that you don't think are bugs should go in the discussions page, but otherwise, yes github is a fine place to ask.

[BirdeeHub]

once you get the package you just put it in your home.packages list

If you have it as a separate flake, and put the packages.${pkgs.stdenv.hostPlatform.system}.<packagename> into your home.packages list

With the function baseBuilder, the result is just a package, so you would install the result like a package.

[BirdeeHub]

I think this template though will be best

https://github.com/BirdeeHub/nixCats-nvim/tree/main/templates/simple

you just call it like home.packages = [ (import ./thedir { inherit pkgs; inherit (inputs) nixCats; }) ];

[flpvsk]

Ok, this worked thanks a lot!

I had to do a couple things differently:

- home.packages = [ (import ./thedir { inherit pkgs; inherit (inputs) nixCats; }) ];
+ home.packages = [ (import ./thedir { inherit pkgs; }) ]; # i guess bc there was no @inputs var

And in simple/default.nix

{
  pkgs ? import <nixpkgs> {}
  , nixCats ? builtins.fetchGit {
    url = "https://github.com/BirdeeHub/nixCats-nvim";
+   rev = "<latest-commit>";
  }
  , ...
}

[BirdeeHub]

So, that is fetching it directly, you fetched it with builtins.fetchGit. This is fine, it works, although you will have to update that rev manually when nixCats updates. nixCats was designed to work regardless of if you import it as a flake or not, which is why this works.

If you decide to swap to using flakes eventually, you can grab nixCats from your flake inputs, thats what that inherit (inputs) nixCats is, I, possibly incorrectly, assumed that you were using flakes, and had a flake input with nixCats in it.

[flpvsk]

I am using flakes, but I might need some help to pass the nixCats from the flake down to the module that defines packages.

I assume I add nixCats as a dependency to the flake here

Like this:

{
  # ...
  inputs = {
    nixCats = {
      url = "github:BirdeeHub/nixCats-nvim";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };
  outputs = { otherInputs, nixCats } @inputs
  # ...
}

And if I follow the string of imports it looks like this:

./flake.nix calls darwinSystem with
./hosts/darwin/default.nix that has one of the imports defined as
./modules/darwin/home-manager.nix that uses callPackage on
./modules/darwin/packages.nix that imports
./modules/shared/packages.nix where I'd like to add the nvim package to, so I should have nixCats dependency available

Is there a way to pass nixCats from the flake through that mess of a chain?

[BirdeeHub]

put inputs (the whole thing) in specialArgs for nixos and extraSpecialArgs for home-manager is the general way, that adds it to the module arguments

If you wanted to import the module separate from your config on another system, you would also have to add the same inputs on that other system unfortunately, so only use this technique/argument for your core config generally.

In your case, this is your main config, and this exact case is what it was made for.

For more portable solution, usually people break it up into smaller modules, and then make their module files into files that take an inputs and return a module, that way the module returned from the file has the inputs rolled into it. But since you are building and installing the thing within the same config, and the actual template is already just a function which you can call on its own and not a module, it doesnt much matter, but I would be doing you a disservice if I didn't mention it. Its common enough that nixpkgs has lib.importApply for it lol (its just import but adds module location metadata)

[BirdeeHub]

Oh wait I took a look.

You do this

specialArgs = inputs;

You can already grab nixCats directly from your module arguments.

{config, lib, pkgs, nixCats, ... }:

Generally people do

specialArgs = { inherit inputs; };

Because it allows you to then pass them along again easier because you can grab them as a unit.

However you could do this even if you wanted

specialArgs = inputs // { inherit inputs; };

Then you get both lol

[BirdeeHub]

oh also

This might sound odd but nixCats doesnt have any flake inputs. No need for follows. You pass it a pkgs and it bundles the little bit of the lib it needs outside of that. It doesnt need any.

Thats also how it works without being a flake input so easily, although there are several ways to achieve that.