core/pkgs/top-level/impure.nix

/*
  Impure default args for `pkgs/top-level/default.nix`. See that file
  for the meaning of each argument.
*/

let

  homeDir = builtins.getEnv "HOME";

  # Return ‘x’ if it evaluates, or ‘def’ if it throws an exception.
  try =
    x: def:
    let
      res = builtins.tryEval x;
    in
    if res.success then res.value else def;

in

{
  # We put legacy `system` into `localSystem`, if `localSystem` was not passed.
  # If neither is passed, assume we are building packages on the current
  # (build, in GNU Autotools parlance) platform.
  localSystem ? {
    system = args.system or builtins.currentSystem;
  },

  # These are needed only because nix's `--arg` command-line logic doesn't work
  # with unnamed parameters allowed by ...
  system ? localSystem.system,
  crossSystem ? localSystem,

  # Fallback: The contents of the configuration file found at $NIXPKGS_CONFIG or
  # $HOME/.config/nixpkgs/config.nix.
  config ?
    let
      configFile = builtins.getEnv "NIXPKGS_CONFIG";
      configFile2 = homeDir + "/.config/nixpkgs/config.nix";
      configFile3 = homeDir + "/.nixpkgs/config.nix"; # obsolete
    in
    if configFile != "" && builtins.pathExists configFile then
      import configFile
    else if homeDir != "" && builtins.pathExists configFile2 then
      import configFile2
    else if homeDir != "" && builtins.pathExists configFile3 then
      import configFile3
    else
      { },

  # Overlays are used to extend Nixpkgs collection with additional
  # collections of packages.  These collection of packages are part of the
  # fix-point made by Nixpkgs.
  overlays ?
    let
      isDir = path: builtins.pathExists (path + "/.");
      pathOverlays = try (toString <nixpkgs-overlays>) "";
      homeOverlaysFile = homeDir + "/.config/nixpkgs/overlays.nix";
      homeOverlaysDir = homeDir + "/.config/nixpkgs/overlays";
      overlays =
        path:
        # check if the path is a directory or a file
        if isDir path then
          # it's a directory, so the set of overlays from the directory, ordered lexicographically
          let
            content = builtins.readDir path;
          in
          map (n: import (path + ("/" + n))) (
            builtins.filter (
              n:
              (
                builtins.match ".*\\.nix" n != null
                &&
                  # ignore Emacs lock files (.#foo.nix)
                  builtins.match "\\.#.*" n == null
              )
              || builtins.pathExists (path + ("/" + n + "/default.nix"))
            ) (builtins.attrNames content)
          )
        else
          # it's a file, so the result is the contents of the file itself
          import path;
    in
    if pathOverlays != "" && builtins.pathExists pathOverlays then
      overlays pathOverlays
    else if builtins.pathExists homeOverlaysFile && builtins.pathExists homeOverlaysDir then
      throw ''
        Nixpkgs overlays can be specified with ${homeOverlaysFile} or ${homeOverlaysDir}, but not both.
        Please remove one of them and try again.
      ''
    else if builtins.pathExists homeOverlaysFile then
      if isDir homeOverlaysFile then
        throw (homeOverlaysFile + " should be a file")
      else
        overlays homeOverlaysFile
    else if builtins.pathExists homeOverlaysDir then
      if !(isDir homeOverlaysDir) then
        throw (homeOverlaysDir + " should be a directory")
      else
        overlays homeOverlaysDir
    else
      [ ],

  crossOverlays ? [ ],

  ...
}@args:

# If `localSystem` was explicitly passed, legacy `system` should
# not be passed, and vice-versa.
assert args ? localSystem -> !(args ? system);
assert args ? system -> !(args ? localSystem);

import ./. (builtins.removeAttrs args [ "system" ] // { inherit config overlays localSystem; })