5

I want to run a nix-shell with the following packages installed:

  • aspell
  • aspellDicts.en
  • hello

I can't simply do: nix-shell -p aspell aspellDicts.en hello --pure as this will not correctly install the aspell dictionaries. Nix provides a aspellWithDict function that can be used to build aspell with dictionaries:

nix-build -E 'with import <nixpkgs> {}; aspellWithDicts (d: [d.en])'

I want to use the result of this build as a dependency in another local package (foo). This is how I'm currently achieving this:

./pkgs/aspell-with-dicts/default.nix:

with import <nixpkgs> {};

aspellWithDicts (d: [d.en])

./pkgs/foo/default.nix:

{stdenv, aspellWithDicts, hello}:

stdenv.mkDerivation rec {
    name = "foo";
    buildInputs = [ aspellWithDicts hello ];
}

./custom-packages.nix:

{ system ? builtins.currentSystem }:

let
  pkgs = import <nixpkgs> { inherit system; };

in

rec {
  aspellWithDicts = import ./pkgs/aspell-with-dicts;

  foo = import ./pkgs/foo {
    aspellWithDicts = aspellWithDicts;
    hello = pkgs.hello;
    stdenv = pkgs.stdenv;
  };
}

Running the shell works as expected: nix-shell ./custom-packages.nix -A foo --pure

So my solution works, but could this outcome be achieved in a more succinct idiomatic way?

b73
  • 1,377
  • 2
  • 14
  • 25
  • Where do you want your `foo` package to go? Is it something you want to upstream into the NixPkgs repository? Or is it a package that you only ever want to install locally? Maybe you want to use it in your company? – Robert Hensing Dec 01 '17 at 15:10
  • For this instance `foo` is something that I just want to use locally. – b73 Dec 01 '17 at 16:07

2 Answers2

4

Do you need to build foo? What in foo you will use?

Assume you only want to use the shell via nix-shell and not want to build/install anything using nix-build or nix-env -i, this should works.

The following shell.nix 

with import <nixpkgs> {};
with pkgs;

let
  myAspell = aspellWithDicts (d: [d.en]);
in
  stdenv.mkDerivation {
    name = "myShell";

    buildInputs = [myAspell hello];

    shellHooks = ''
      echo Im in $name.
      echo aspell is locate at ${myAspell}
      echo hello is locate at ${hello}
    '';
  }

will give you a shell with aspell and hello

$ nix-shell
Im in myShell.
aspell is locate at /nix/store/zcclppbibcg4nfkis6zqml8cnrlnx00b-aspell-env
hello is locate at /nix/store/gas2p68jqbzgb7zr96y5nc8j7nk61kkk-hello-2.10

If it is the case that foo have some code to build and install.

mkDerivation in foo/default.nix must have src field which could be src = ./.; or something like fetchurl or fetchFromGithub (see document for examples).

Then you can use callPackages or import (depends on how the nix expression was written) with foo/default.nix as argument to bring what foo provided to use in this shell.

If you try to build this shell.nix (or foo/default.nix) it will failed with missing src

$ nix-build shell.nix 
these derivations will be built:
  /nix/store/20h8cva19irq8vn39i72j8iz40ivijhr-myShell.drv
building path(s) ‘/nix/store/r1f6qpxz91h5jkj7hzrmaymmzi9h1yml-myShell’
unpacking sources
variable $src or $srcs should point to the source
builder for ‘/nix/store/20h8cva19irq8vn39i72j8iz40ivijhr-myShell.drv’ failed with exit code 1
error: build of ‘/nix/store/20h8cva19irq8vn39i72j8iz40ivijhr-myShell.drv’ failed
wizzup
  • 2,361
  • 20
  • 34
  • 1
    Thanks wizzup, correct me if I'm wrong but I think the `buildInputs` in your example should actually be `[myAspell hello]`. If I make this amendment then your example works as expected. – b73 Dec 02 '17 at 15:10
  • If `shell.nix` did have a requirement to do some building, could it not simply be invoked using `nix-build`? Your `shell.nix` doesn't define a top level function and thus doesn't require dependencies to be passed in as arguments. So I'm unclear as to why there would be a need to use `callPackage` or `import` if `shell.nix` did build something? Appreciate your advise. – b73 Dec 02 '17 at 16:07
  • I mean `foo` doesn't seem to provide any output because `src` is missing so I just skip it. Running `nix-build foo/default.nix` would failed anyway. – wizzup Dec 03 '17 at 05:12
  • thanks for the info, especially useful to see the use of 'shellHooks'. – b73 Dec 03 '17 at 17:28
2

To make this code more idiomatic, I have the following suggestions:

callPackage

Use the pkgs.callPackage function. It will take care of passing the arguments that your derivation needs. This is why many files in NixPkgs look like { dependency, ...}: something. The first argument is the function you want to inject dependencies into and the second argument is an attribute set that you can use to pass some dependencies manually.

By using callPackage you do not need to import <nixpkgs> {}, so your code will be easier to use in new contexts <nixpkgs> can't be used and it will evaluate a bit faster because it has to evaluate the NixPkgs fix-point only once.

(Of course you have to import <nixpkgs> once to get started, but after that, there should be no need.)

with

In pkgs/aspell-with-dicts/default.nix you use a with keyword, which is ok, but in this case it does not really add value. I prefer to refer to variables explicitly, so prefer to read pkgs.something when it's used once or twice, or inherit (pkgs) something if it's use more often. This way the reader can easily determine where a variable comes from.

I do use it when experimenting with unfamiliar packages or functions, because maintenance is not an issue then.

pkgs/aspell-with-dicts/default.nix

Unless you expect that your instantiation of aspell is something you want to reuse, it's probably easier to just construct it where you use it.

If you do expect to reuse a specific configuration of a package, you might want to make it a first class package by constructing it in an overlay.

That's it. I think the most important point is avoiding <nixpkgs> and apart from that it's already pretty idiomatic.

I don't know what your mysterious foo is, but if it's open source, please consider upstreaming it into NixPkgs. Nix has a very welcoming community in my experience.

Robert Hensing
  • 6,708
  • 18
  • 23