{

config,

lib,

pkgs,

options,

...

}:

let

cfg = config.devshell;

sanitizedName = lib.strings.sanitizeDerivationName cfg.name;

ansi = import ../nix/ansi.nix;

bashBin = "${cfg.bashPackage}/bin";

bashPath = "${cfg.bashPackage}/bin/bash";

# Because we want to be able to push pure JSON-like data into the

# environment.

strOrPackage = import ../nix/strOrPackage.nix { inherit lib pkgs; };

# Use this to define a flake app for the environment.

mkFlakeApp = bin: {

type = "app";

program = "${bin}";

};

mkSetupHook =

rc:

pkgs.stdenvNoCC.mkDerivation {

name = "devshell-setup-hook";

setupHook = pkgs.writeText "devshell-setup-hook.sh" ''

source ${rc}

'';

dontUnpack = true;

dontBuild = true;

dontInstall = true;

};

mkNakedShell = pkgs.callPackage ../nix/mkNakedShell.nix { };

addAttributeName =

prefix:

lib.mapAttrs (

k: v:

v

// {

text = ''

#### ${prefix}.${k}

${v.text}

'';

}

);

inherit (lib)

mkOption

mkEnableOption

attrNames

attrValues

textClosureMap

replaceStrings

types

id

;

entryOptions = {

text = mkOption {

type = types.str;

description = ''

Script to run.

'';

};

deps = mkOption {

type = types.listOf types.str;

default = [ ];

description = ''

A list of other steps that this one depends on.

'';

};

};

# Write a bash profile to load

envBash = pkgs.writeText "devshell-env.bash" ''

if [[ -n ''${IN_NIX_SHELL:-} || ''${DIRENV_IN_ENVRC:-} = 1 ]]; then

# We know that PWD is always the current directory in these contexts

PRJ_ROOT=$PWD

elif [[ -z ''${PRJ_ROOT:-} ]]; then

${lib.optionalString (cfg.prj_root_fallback != null) cfg.prj_root_fallback}

if [[ -z "''${PRJ_ROOT:-}" ]]; then

echo "ERROR: please set the PRJ_ROOT env var to point to the project root" >&2

return 1

fi

fi

export PRJ_ROOT

# Expose the folder that contains the assembled environment.

export DEVSHELL_DIR=@DEVSHELL_DIR@

# Prepend the PATH with the devshell dir and bash

PATH=''${PATH%:/path-not-set}

PATH=''${PATH#${bashBin}:}

export PATH=$DEVSHELL_DIR/bin:${bashBin}:$PATH

${cfg.startup_env}

${textClosureMap id (addAttributeName "startup" cfg.startup) (attrNames cfg.startup)}

# Interactive sessions

if [[ $- == *i* ]]; then

${textClosureMap id (addAttributeName "interactive" cfg.interactive) (attrNames cfg.interactive)}

fi # Interactive session

'';

# This is our entrypoint script.

entrypoint = pkgs.writeScript "${cfg.name}-entrypoint" ''

#!${bashPath}

# Script that sets-up the environment. Can be both sourced or invoked.

export DEVSHELL_DIR=@DEVSHELL_DIR@

# If the file is sourced, skip all of the rest and just source the env

# script.

if (return 0) &>/dev/null; then

source "$DEVSHELL_DIR/env.bash"

return

fi

# Be strict!

set -euo pipefail

while (( "$#" > 0 )); do

case "$1" in

-h|--help)

help=1

;;

--pure)

pure=1

;;

--prj-root)

if (( "$#" < 2 )); then

echo 1>&2 '${cfg.name}: missing required argument to --prj-root'

exit 1

fi

PRJ_ROOT="$2"

shift

;;

--env-bin)

if (( "$#" < 2 )); then

echo 1>&2 '${cfg.name}: missing required argument to --env-bin'

exit 1

fi

env_bin="$2"

shift

;;

--)

shift

break

;;

*)

break

;;

esac

shift

done

if [[ -n "''${help:-}" ]]; then

${pkgs.coreutils}/bin/cat <<USAGE

Usage: ${cfg.name}

$0 -h | --help # show this help

$0 [--pure] # start a bash sub-shell

$0 [--pure] <cmd> [...] # run a command in the environment

Options:

* --pure : execute the script in a clean environment

* --prj-root <path> : set the project root (\$PRJ_ROOT)

* --env-bin <path> : path to the env executable (default: /usr/bin/env)

USAGE

exit

fi

if (( "$#" == 0 )); then

# Start an interactive shell

set -- ${lib.escapeShellArg bashPath} --rcfile "$DEVSHELL_DIR/env.bash" --noprofile

fi

if [[ -n "''${pure:-}" ]]; then

# re-execute the script in a clean environment.

# note that the `--` in between `"$0"` and `"$@"` will immediately

# short-circuit options processing on the second pass through this

# script, in case we get something like:

# <entrypoint> --pure -- --pure <cmd>

set -- "''${env_bin:-/usr/bin/env}" -i -- ''${HOME:+"HOME=''${HOME:-}"} ''${PRJ_ROOT:+"PRJ_ROOT=''${PRJ_ROOT:-}"} "$0" -- "$@"

else

# Start a script

source "$DEVSHELL_DIR/env.bash"

fi

exec -- "$@"

'';

# Builds the DEVSHELL_DIR with all the dependencies

devshell_dir = pkgs.buildEnv rec {

name = "${sanitizedName}-dir";

paths = cfg.packages;

postBuild = ''

substitute ${envBash} $out/env.bash --subst-var-by DEVSHELL_DIR $out

substitute ${entrypoint} $out/entrypoint --subst-var-by DEVSHELL_DIR $out

chmod +x $out/entrypoint

mainProgram="${meta.mainProgram}"

# ensure mainProgram doesn't collide

if [ -e "$out/bin/$mainProgram" ]; then

echo "Warning: Cannot create entry point for this devshell at '\$out/bin/$mainProgram' because an executable with that name already exists." >&2

echo "Set meta.mainProgram to something else than '$mainProgram'." >&2

else

# if $out/bin is a single symlink, transform it into a directory tree

# (buildEnv does that when there is only one package in the environment)

if [ -L "$out/bin" ]; then

mv "$out/bin" bin-tmp

mkdir "$out/bin"

ln -s bin-tmp/* "$out/bin/"

fi

ln -s $out/entrypoint "$out/bin/$mainProgram"

fi

'';

meta.mainProgram = config.meta.mainProgram or sanitizedName;

};

# Returns a list of all the input derivation ... for a derivation.

inputsOf =

drv:

lib.filter lib.isDerivation (

(drv.buildInputs or [ ])

++ (drv.nativeBuildInputs or [ ])

++ (drv.propagatedBuildInputs or [ ])

++ (drv.propagatedNativeBuildInputs or [ ])

);

in

{

options.devshell = {

bashPackage = mkOption {

internal = true;

type = strOrPackage;

default = pkgs.bashInteractive;

defaultText = "pkgs.bashInteractive";

description = "Version of bash to use in the project";

};

package = mkOption {

internal = true;

type = types.package;

description = ''

This package contains the DEVSHELL_DIR

'';

};

startup = mkOption {

type = types.attrsOf (types.submodule { options = entryOptions; });

default = { };

internal = true;

description = ''

A list of scripts to execute on startup.

'';

};

startup_env = mkOption {

type = types.str;

default = "";

internal = true;

description = ''

Please ignore. Used by the env module.

'';

};

interactive = mkOption {

type = types.attrsOf (types.submodule { options = entryOptions; });

default = { };

internal = true;

description = ''

A list of scripts to execute on interactive startups.

'';

};

# TODO: rename motd to something better.

motd = mkOption {

type = types.str;

default = ''

{202}🔨 Welcome to ${cfg.name}{reset}

$(type -p menu &>/dev/null && menu)

'';

apply = replaceStrings (map (key: "{${key}}") (attrNames ansi)) (attrValues ansi);

description = ''

Message Of The Day.

This is the welcome message that is being printed when the user opens

the shell.

You may use any valid ansi color from the 8-bit ansi color table. For example, to use a green color you would use something like {106}. You may also use {bold}, {italic}, {underline}. Use {reset} to turn off all attributes.

'';

};

load_profiles = mkEnableOption "load etc/profiles.d/*.sh in the shell";

name = mkOption {

type = types.str;

default = "devshell";

description = ''

Name of the shell environment. It usually maps to the project name.

'';

};

meta = mkOption {

type = types.attrsOf types.anything;

default = { };

description = ''

Metadata, such as 'meta.description'. Can be useful as metadata for downstream tooling.

'';

};

packages = mkOption {

type = types.listOf strOrPackage;

default = [ ];

description = ''

The set of packages to appear in the project environment.

Those packages come from <https://nixos.org/NixOS/nixpkgs> and can be

searched by going to <https://search.nixos.org/packages>

'';

};

packagesFrom = mkOption {

type = types.listOf strOrPackage;

default = [ ];

description = ''

Add all the build dependencies from the listed packages to the

environment.

'';

};

shell = mkOption {

internal = true;

type = types.package;

description = "TODO";

};

prj_root_fallback = mkOption {

type =

let

envType = options.env.type.nestedTypes.elemType;

coerceFunc = value: { inherit value; };

in

types.nullOr (types.coercedTo types.nonEmptyStr coerceFunc envType);

apply = x: if x == null then x else x // { name = "PRJ_ROOT"; };

default = {

eval = "$PWD";

};

example = lib.literalExpression ''

{

# Use the top-level directory of the working tree

eval = "$(git rev-parse --show-toplevel)";

};

'';

description = ''

If IN_NIX_SHELL is nonempty, or DIRENV_IN_ENVRC is set to '1', then

PRJ_ROOT is set to the value of PWD.

This option specifies the path to use as the value of PRJ_ROOT in case

IN_NIX_SHELL is empty or unset and DIRENV_IN_ENVRC is any value other

than '1'.

Set this to null to force PRJ_ROOT to be defined at runtime (except if

IN_NIX_SHELL or DIRENV_IN_ENVRC are defined as described above).

Otherwise, you can set this to a string representing the desired

default path, or to a submodule of the same type valid in the 'env'

options list (except that the 'name' field is ignored).

'';

};

};

config.devshell = {

package = devshell_dir;

packages = lib.foldl' (sum: drv: sum ++ (inputsOf drv)) [ ] cfg.packagesFrom;

startup = {

motd = lib.noDepEntry ''

__devshell-motd() {

${pkgs.coreutils}/bin/cat <<DEVSHELL_PROMPT

${cfg.motd}

DEVSHELL_PROMPT

}

if [[ ''${DEVSHELL_NO_MOTD:-} = 1 ]]; then

# Skip if that env var is set

:

elif [[ ''${DIRENV_IN_ENVRC:-} = 1 ]]; then

# Print the motd in direnv

__devshell-motd

else

# Print information if the prompt is displayed. We have to make

# that distinction because `nix-shell -c "cmd"` is running in

# interactive mode.

__devshell-prompt() {

__devshell-motd

# Make it a noop

__devshell-prompt() { :; }

}

PROMPT_COMMAND=__devshell-prompt''${PROMPT_COMMAND+;$PROMPT_COMMAND}

fi

'';

}

// (lib.optionalAttrs cfg.load_profiles {

load_profiles = lib.noDepEntry ''

# Load installed profiles

for file in "$DEVSHELL_DIR/etc/profile.d/"*.sh; do

# If that folder doesn't exist, bash loves to return the whole glob

[[ -f "$file" ]] && source "$file"

done

'';

});

interactive = {

PS1_util = lib.noDepEntry ''

if [[ -n "''${PRJ_ROOT:-}" ]]; then

# Print the path relative to $PRJ_ROOT

rel_root() {

local path

path=$(${pkgs.coreutils}/bin/realpath --relative-to "$PRJ_ROOT" "$PWD")

if [[ $path != . ]]; then

echo " $path "

fi

}

else

# If PRJ_ROOT is unset, print only the current directory name

rel_root() {

echo " \W "

}

fi

'';

# Set a cool PS1

PS1 = lib.stringAfter [ "PS1_util" ] (

lib.mkDefault ''

__set_prompt() {

PS1='\[\033[38;5;202m\][${cfg.name}]$(rel_root)\$\[\033[0m\] '

}

# Only set the prompt when entering a nix shell, since nix shells

# always reset to plain bash, otherwise respect the user's preferences

[[ -n "''${IN_NIX_SHELL:-}" ]] && __set_prompt

unset -f __set_prompt

''

);

};

# Use a naked derivation to limit the amount of noise passed to nix-shell.

shell = mkNakedShell {

name = sanitizedName;

meta =

# set default for meta.mainProgram here to gain compatibility with:

# `lib.getExe`, `nix run`, `nix bundle`, etc.

{

mainProgram = cfg.package.meta.mainProgram;

}

// cfg.meta;

profile = cfg.package;

passthru = {

inherit config;

# keep flakeApp attribute for backward compatibility

flakeApp = mkFlakeApp "${devshell_dir}/entrypoint";

hook = mkSetupHook "${devshell_dir}/env.bash";

inherit (config._module.args) pkgs;

};

};

};

}