nvf/flake/packages.nix

{
  inputs,
  self,
  ...
} @ args: {
  perSystem = {
    config,
    pkgs,
    lib,
    ...
  }: let
    inherit (lib.customisation) makeScope;
    inherit (lib.attrsets) isDerivation isAttrs concatMapAttrs;
    inherit (lib.strings) concatStringsSep;
    inherit (lib.filesystem) packagesFromDirectoryRecursive;

    # Entrypoint for nvf documentation and relevant packages.
    docs = import ../docs {inherit pkgs inputs lib;};

    # Helper function for creating demo configurations for nvf
    # TODO: make this more generic.
    buildPkg = maximal:
      (args.config.flake.lib.nvim.neovimConfiguration {
        inherit pkgs;
        modules = [(import ../configuration.nix maximal)];
      }).neovim;

    # This constructs a by-name overlay similar to the one found in Nixpkgs.
    # The goal is to automatically discover and packages found in pkgs/by-name
    # as long as they have a 'package.nix' in the package directory. We also
    # pass 'inputs' and 'pins' to all packages in the 'callPackage' scope, therefore
    # they are always available in the relevant 'package.nix' files.
    # ---
    # The logic is borrowed from drupol/pkgs-by-name-for-flake-parts, available
    # under the MIT license.
    flattenPkgs = separator: path: value:
      if isDerivation value
      then {
        ${concatStringsSep separator path} = value;
      }
      else if isAttrs value
      then concatMapAttrs (name: flattenPkgs separator (path ++ [name])) value
      else
        # Ignore the functions which makeScope returns
        {};

    inputsScope = makeScope pkgs.newScope (_: {
      inherit inputs;
      inherit (self) pins;
    });

    scopeFromDirectory = directory:
      packagesFromDirectoryRecursive {
        inherit directory;
        inherit (inputsScope) newScope callPackage;
      };

    legacyPackages = scopeFromDirectory ./pkgs/by-name;
  in {
    packages =
      (flattenPkgs "/" [] legacyPackages)
      // {
        inherit (docs.manual) htmlOpenTool;

        # Documentation
        docs = docs.manual.html;
        docs-html = docs.manual.html;
        docs-manpages = docs.manPages;
        docs-json = docs.options.json;
        docs-linkcheck = let
          site = config.packages.docs;
        in
          pkgs.testers.lycheeLinkCheck {
            inherit site;

            remap = {
              "https://notashelf.github.io/nvf/" = "${site}/share/doc/";
              "https://nvf.notashelf.dev/" = "${site}/share/doc/";
            };

            extraConfig = {
              exclude = [
                # This is not an email, but just part of an SCM query inside a nix code block.
                # The leading escaped non breaking space is there on purpose.
                "%C2%A0@injection.content"
              ];
              include_mail = true;
              include_verbatim = true;
            };
          };

        # Helper utility for building the HTML manual and opening it in the
        # browser with $BROWSER or using xdg-open as a fallback tool.
        # Adapted from Home-Manager, available under the MIT license.
        docs-html-wrapped = let
          xdg-open = lib.getExe' pkgs.xdg-utils "xdg-open";
          docs-html = docs.manual.html + /share/doc/nvf;
        in
          pkgs.writeShellScriptBin "docs-html-wrapped" ''
            set -euo pipefail

            if [[ ! -v BROWSER || -z $BROWSER ]]; then
              for candidate in xdg-open open w3m; do
              BROWSER="$(type -P $candidate || true)"
                if [[ -x $BROWSER ]]; then
                  break;
                fi
              done
            fi

            if [[ ! -v BROWSER || -z $BROWSER ]]; then
              echo "$0: unable to start a web browser; please set \$BROWSER"
              echo "$0: Trying xdg-open as a fallback"
              ${xdg-open} ${docs-html}/index.xhtml
            else
              echo "\$BROWSER is set. Attempting to open manual"
              exec "$BROWSER" "${docs-html}/index.xhtml"
            fi
          '';

        docs-zim = pkgs.stdenv.mkDerivation {
          name = "nvf-docs-zim";
          dontUnpack = true;

          buildInputs = [pkgs.zim-tools];

          installPhase = ''
            mkdir -p $out

            zimwriterfs \
              --welcome 'index.html' \
              --illustration 'assets/logo.png' \
              --language 'eng' \
              --name 'mvf-manual' \
              --title 'NVF Manual' \
              --description 'nvf is a modular and extensible Neovim configuration framework built for Nix' \
              --longDescription 'nvf is a highly modular, configurable, extensible and easy to use Neovim configuration framework built for and designed to be used with Nix. Boasting flexibility, robustness and ease of use (among other positive traits), this project allows you to configure a fully featured Neovim instance with a few lines of Nix while leaving all kinds of doors open for integrating Lua in your configurations whether you are a beginner or an advanced user.' \
              -c 'NotAShelf and NVF Contributors' \
              -p 'NotAShelf and NVF Contributors' \
              --tags 'devdocs;nix' \
              --source 'https://nvf.notashelf.dev/' \
              --scraper 'ndg' \
              ${docs.manual.html}/share/doc $out/nvf.zim
          '';
        };
        # Exposed neovim configurations
        nix = buildPkg false;
        maximal = buildPkg true;
        default = config.packages.nix;
      };
  };
}