streamd/flake.nix

{
  description = "Using Markdown Files to organize your life as a @Tag-Stream";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";

    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    crane.url = "github:ipetkov/crane";

    git-hooks = {
      url = "github:cachix/git-hooks.nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      rust-overlay,
      crane,
      git-hooks,
      ...
    }:
    let
      inherit (nixpkgs) lib;
      forAllSystems = lib.genAttrs lib.systems.flakeExposed;

      # Read version from Cargo.toml as single source of truth
      version = (builtins.fromTOML (builtins.readFile ./Cargo.toml)).package.version;

      mkPkgs =
        system:
        import nixpkgs {
          inherit system;
          overlays = [ rust-overlay.overlays.default ];
        };

      mkCraneLib =
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default.override {
            extensions = [
              "rust-src"
              "rust-analyzer"
            ];
          };
        in
        (crane.mkLib pkgs).overrideToolchain toolchain;

      mkStreamd =
        system:
        let
          craneLib = mkCraneLib system;

          commonArgs = {
            src = craneLib.path ./.;
            pname = "streamd";
            inherit version;
            strictDeps = true;
          };

          cargoArtifacts = craneLib.buildDepsOnly commonArgs;
        in
        craneLib.buildPackage (
          commonArgs
          // {
            inherit cargoArtifacts;

            passthru = {
              inherit cargoArtifacts;
              tests = {
                clippy = craneLib.cargoClippy (
                  commonArgs
                  // {
                    inherit cargoArtifacts;
                    cargoClippyExtraArgs = "--all-targets -- -D warnings";
                  }
                );
                fmt = craneLib.cargoFmt { src = commonArgs.src; };
                test = craneLib.cargoTest (commonArgs // { inherit cargoArtifacts; });
              };
            };
          }
        );

      mkGitHooksCheck =
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default;
        in
        git-hooks.lib.${system}.run {
          src = ./.;
          hooks = {
            rustfmt = {
              enable = true;
              package = toolchain;
            };
            commitizen.enable = true;
          };
        };
    in
    {
      packages = forAllSystems (
        system:
        let
          streamd = mkStreamd system;
        in
        {
          inherit streamd;
          default = streamd;
        }
      );

      homeManagerModules.default =
        {
          lib,
          config,
          pkgs,
          ...
        }:
        let
          cfg = config.programs.streamd;
        in
        {
          options.programs.streamd = {
            enable = lib.mkEnableOption "streamd";

            base-folder = lib.mkOption {
              type = lib.types.str;
              description = "Base Folder of streamd";
            };

            package = lib.mkOption {
              type = lib.types.package;
              default = self.packages.${pkgs.stdenv.hostPlatform.system}.streamd;
              defaultText = lib.literalExpression "inputs.streamd.packages.\${pkgs.stdenv.hostPlatform.system}.streamd";
              description = "The package to use for the streamd binary.";
            };
          };

          config = lib.mkIf cfg.enable {
            assertions = [
              (lib.hm.assertions.assertPlatform "programs.streamd" pkgs lib.platforms.linux)
            ];

            home.packages = [ cfg.package ];

            xdg.configFile."streamd/config.toml".source =
              (pkgs.formats.toml { }).generate "streamd-configuration"
                {
                  base_folder = cfg.base-folder;
                };

            home.shellAliases.s = "streamd";

            programs.bash.initExtra = ''
              eval "$(${cfg.package}/bin/streamd completions bash)"
            '';

            programs.zsh.initExtra = ''
              eval "$(${cfg.package}/bin/streamd completions zsh)"
            '';
          };
        };

      checks = forAllSystems (
        system:
        let
          streamd = mkStreamd system;
        in
        {
          inherit (streamd.passthru.tests) clippy fmt test;
          pre-commit = mkGitHooksCheck system;
        }
      );

      devShells = forAllSystems (
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default.override {
            extensions = [
              "rust-src"
              "rust-analyzer"
            ];
          };
        in
        {
          default = pkgs.mkShell {
            packages = [
              toolchain
              pkgs.commitizen
            ];

            shellHook = ''
              ${(mkGitHooksCheck system).shellHook}
            '';
          };
        }
      );
    };
}