-*- mode: org -*-
#+TITLE:       configuration nix
#+DESCRIPTION: makefile for spine
#+FILETAGS:    :spine:build:tools:
#+AUTHOR:      Ralph Amissah
#+EMAIL:       [[mailto:ralph.amissah@gmail.com][ralph.amissah@gmail.com]]
#+COPYRIGHT:   Copyright (C) 2015 - 2023 Ralph Amissah
#+LANGUAGE:    en
#+STARTUP:     show4levels hideblocks hidestars noindent entitiespretty
#+PROPERTY:    header-args  :exports code
#+PROPERTY:    header-args+ :noweb yes
#+PROPERTY:    header-args+ :results no
#+PROPERTY:    header-args+ :cache no
#+PROPERTY:    header-args+ :padline no
#+PROPERTY:    header-args+ :mkdirp yes
#+OPTIONS:     H:3 num:nil toc:t \n:t ::t |:t ^:nil -:t f:t *:t

* nix :nix:
** flake.nix :flake:

#+HEADER: :tangle ../flake.nix
#+HEADER: :noweb yes
#+BEGIN_SRC nix
{
  description = "a sisu like document parser search form";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; # "github:nixos/nixpkgs"; "github:NixOS/nixpkgs/nixpkgs-unstable"; "nixpkgs/nixos-unstable"; "nixpkgs/nixos-21.11";
  inputs.flake-utils.url = "github:numtide/flake-utils";
  outputs = {
    self,
    nixpkgs,
    flake-utils,
  } @ inputs: let
    pname = "spine_search";
    version = "<<spine_version_set>>";
    shell = ./shell.nix; # ./default.nix;
    devEnv = ./.envrc; # ./shell.nix; # ./default.nix;
    supportedSystems = ["x86_64-linux"]; # [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ];
    forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
    nixpkgsFor = forAllSystems (system: import nixpkgs {inherit system;}); # nixpkgs instantiated for supported system types.
    checkPhase = ''
      runHook preCheck
      dub test --combined --skip-registry=all
      runHook postCheck
    '';
    installPhase = ''
      runHook preInstall
      mkdir -p $out/share/cgi-bin
      install -m755 -D ./cgi-bin/spine_search $out/share/cgi-bin/spine_search
      runHook postInstall
    '';
    postInstall = ''
      echo `ls -la $out/share/cgi-bin/spine_search`
    '';
  in {
    packages = forAllSystems (system: let
      pkgs = nixpkgsFor.${system};
    in
      with pkgs; {
        default = stdenv.mkDerivation {
          inherit pname;
          inherit version;
          executable = true;
          src = self;
          inherit shell;
          inherit devEnv;
          buildInputs = [sqlite];
          nativeBuildInputs = [dub ldc gnumake]; # [ dub dmd ]; [ dub ldc ]; [ dub gdc ];
          buildPhase = ''
            runHook preBuild
            for DC_ in dmd ldmd2 ldc2 gdc gdmd; do
              echo "- check for D compiler $DC_"
              DC=$(type -P $DC_ || echo "")
              if [ ! "$DC" == "" ]; then break; fi
            done
            if [ "$DC" == "" ]; then exit "Error: could not find D compiler"; fi
            echo "$DC_ used as D compiler to build $pname"
            dub build --compiler=$DC --build=$DC_ --combined --skip-registry=all
            runHook postBuild
          '';
          inherit checkPhase;
          inherit installPhase;
          inherit postInstall;
        };
        spine-search-dmd = stdenv.mkDerivation {
          inherit pname;
          inherit version;
          meta.mainProgram = "spine_search-dmd";
          executable = true;
          src = self;
          inherit shell;
          inherit devEnv;
          buildInputs = [sqlite];
          nativeBuildInputs = [dub dmd gnumake];
          buildPhase = ''
            runHook preBuild
            dub build --compiler=$(type -P dmd) --build=dmd --combined --skip-registry=all
            runHook postBuild
          '';
          inherit checkPhase;
          inherit installPhase;
          inherit postInstall;
        };
        spine-search-ldc = stdenv.mkDerivation {
          inherit pname;
          inherit version;
          meta.mainProgram = "spine_search-ldc";
          executable = true;
          src = self;
          inherit shell;
          inherit devEnv;
          buildInputs = [sqlite];
          nativeBuildInputs = [dub ldc gnumake];
          buildPhase = ''
            runHook preBuild
            dub build --compiler=$(type -P ldc2) --build=ldc2 --combined --skip-registry=all
            runHook postBuild
          '';
          inherit checkPhase;
          inherit installPhase;
          inherit postInstall;
        };
        #spine-search-gdc = stdenv.mkDerivation {
        #  inherit pname;
        #  inherit version;
        #  meta.mainProgram = "spine_search-gdc";
        #  executable = true;
        #  src = self;
        #  inherit shell;
        #  inherit devEnv;
        #  buildInputs = [ sqlite ];
        #  nativeBuildInputs = [ dub gdc gnumake ];
        #  buildPhase = ''
        #    runHook preBuild
        #    dub build --compiler=$(type -P gdc) --build=gdc --combined --skip-registry=all
        #    runHook postBuild
        #  '';
        #  inherit checkPhase;
        #  inherit installPhase;
        #  inherit postInstall;
        #};
        #vendorSha256 = "sha256-0Q00000000000000000000000000000000000000000=";
      });
    devShells = forAllSystems (system: let
      pkgs = nixpkgsFor.${system};
      shellHook = ''
        export DFLAGS="-O2 -inline -boundscheck=on -color=on"
        export Date=`date "+%Y%m%d"`
        ## set local values in .envrc-local (or here if you must)
      '';
    in
      with pkgs; {
        devShell = mkShell {
          name = "spine base dev shell";
          inherit shell;
          inherit devEnv;
          #buildInputs = [ sqlite ];
          #nativeBuildInputs = [ dub dmd ldc gdc gnumake ];
          packages = [
            sqlite
            dub
            dmd
            ldc
            gnumake
          ];
          inherit shellHook;
        };
        devShell-sqlite = mkShell {
          name = "spine dev shell for latex & pdf output";
          inherit shell;
          inherit devEnv;
          packages = [
            dub
            #dmd
            ldc
            gnumake
            sqlite
          ];
          inherit shellHook;
        };
        default = import ./shell.nix {inherit pkgs;};
      });
  };
}
#+END_SRC

** shell.nix :shell:

#+HEADER: :tangle ../shell.nix
#+HEADER: :tangle-mode (identity #o755)
#+HEADER: :shebang "#!/usr/bin/env -S nix-shell --pure\n#!nix-shell -i bash"
#+HEADER: :noweb yes
#+BEGIN_SRC nix
{pkgs ? import <nixpkgs> {}}:
with pkgs;
  mkShell {
    buildInputs = [
      # ❯❯❯ nix_related
      #nix
      direnv
      nixVersions.unstable #nixFlakes
      nix-prefetch-git
      validatePkgConfig
      nix-output-monitor
      nix-tree
      jq
      alejandra
      git
      # ❯❯❯ dev
      gnumake
      ps
      # ❯❯❯ d_build_related
      # ❯❯ package manager
      dub
      # ❯❯ compiler
      ldc
      #rund
      # ❯❯ linker
      #lld
      #mold
      # ❯❯ builder
      #ninja
      #meson
      # ❯❯❯ sqlite search related
      sqlite
      # ❯❯❯ tools
      #aria #wget #curl
    ];
    shellHook = ''
      echo '
        shell.nix echo ❯❯

        ❯❯ nix flake update && nix flake check --show-trace && nix flake show && nix develop ".#devShell" -c zsh

        ❯❯ nix develop
        ❯❯ nix develop -c zsh

        ❯❯ nix build
        ❯❯ nix build ".#default" --print-build-logs
        ❯❯ nix build ".#spine-search-dmd" --print-build-logs |& nom
        ❯❯ nix build ".#spine-search-ldc" --print-build-logs |& nom

        ❯❯ dub build --compiler=ldmd --build=release --combined --skip-registry=all
      '
    '';
  }
#+END_SRC

echo "ldc `${pkgs.ldc}/bin/ldc2 -v`"

** default.nix :default:

#+HEADER: :tangle ../default.nix
#+HEADER: :tangle-mode (identity #o755)
#+HEADER: :shebang "#!/usr/bin/env -S nix-build"
#+BEGIN_SRC nix
{pkgs ? import <nixpkgs> {}}:
pkgs.callPackage ./devenv.nix {}
#+END_SRC

#+HEADER: :tangle-mode (identity #o755)
#+HEADER: :shebang "#!/usr/bin/env -S nix-build"
#+BEGIN_SRC nix
{ pkgs ? import <nixpkgs> {} }:
pkgs.callPackage ./derivation.nix {}
#+END_SRC

*** devenv.nix :default:devenv:

#+HEADER: :tangle ../devenv.nix
#+HEADER: :tangle-mode (identity #o644)
#+BEGIN_SRC nix
{
  pkgs ? import <nixpkgs> {},
  name ? "user-env",
}:
with pkgs;
  buildEnv {
    inherit name;
    extraOutputsToInstall = ["out" "man" "lib"]; # to get all needed symlinks
    paths = [
      # ❯❯❯ nix_related
      #nix # if not on NixOS, this is needed
      direnv
      nixVersions.unstable #nixFlakes
      nix-prefetch-git
      validatePkgConfig
      nix-output-monitor
      nix-tree
      jq
      alejandra
      git
      # ❯❯❯ dev
      gnumake
      ps
      # ❯❯❯ d_build_related
      # ❯❯ package manager
      dub
      # ❯❯ compiler
      #dmd
      ldc
      # ❯❯❯ sqlite search related
      sqlite
      # this will create a script that will rebuild and upgrade your setup; using shell script syntax
      (writeScriptBin "nix-rebuild" ''
        #!${stdenv.shell}
        #cd <path-to-flake> || exit 1
        nix flake update
        nix profile upgrade '.*'
      '')
      # puts in your root the nixpkgs version
      (writeTextFile {
        name = "nixpkgs-version";
        destination = "/nixpkgs-version";
        text = lib.version;
      })
    ];
  }
#+END_SRC

** derivation.nix :default:

#+HEADER: :tangle ../derivation.nix
#+HEADER: :tangle-mode (identity #o644)
#+HEADER: :noweb yes
#+BEGIN_SRC nix
{
  pkgs ? import <nixpkgs> {},
  stdenv ? pkgs.stdenv,
  lib ? pkgs.lib,
  ldc ? null,
  dcompiler ? pkgs.ldc,
  dub ? pkgs.dub,
}:
assert dcompiler != null;
with (
  with lib; let
    filterDub = name: type: let
      baseName = baseNameOf (toString name);
    in
      ! ( # filter function to remove the .dub package folder from src
        type == "directory" && baseName == ".dub"
      );
    targetOf = package: "${package.targetPath or "."}/${package.targetName or package.name}";
    # remove reference to build tools and library sources
    disallowedReferences = deps: [dcompiler dub];
    removeExpr = refs: ''remove-references-to ${lib.concatMapStrings (ref: " -t ${ref}") refs}'';
  in {
    mkDubDerivation = lib.makeOverridable ({
        src,
        nativeBuildInputs ? [],
        dubJSON ? src + "/dub.json",
        passthru ? {},
        package ? lib.importJSON dubJSON,
        ...
      } @ attrs:
        stdenv.mkDerivation (attrs
          // {
            pname = package.name;
            nativeBuildInputs = [dcompiler dub pkgs.removeReferencesTo] ++ nativeBuildInputs;
            disallowedReferences = disallowedReferences deps;
            passthru =
              passthru
              // {
                inherit dub dcompiler pkgs;
              };
            src = lib.cleanSourceWith {
              filter = filterDub;
              src = lib.cleanSource src;
            };
            preFixup = ''
              find $out/share/cgi-bin -type f -exec ${removeExpr (disallowedReferences deps)} '{}' + || true
            '';
            buildPhase = ''
              runHook preBuild
              HOME="$PWD"
              DFLAGS="-O2 -inline"
              for DC_ in dmd ldmd2 gdmd; do
                echo "- check for D compiler $DC_"
                DC=$(type -P $DC_ || echo "")
                if [ ! "$DC" == "" ]; then
                  break
                fi
              done
              if [ "$DC" == "" ]; then
                exit "Error: could not find D compiler"
              fi
              echo "$DC_ used as D compiler to build $pname"
              dub build --compiler=$DC --build=release --combined --skip-registry=all
              runHook postBuild
            '';
            checkPhase = ''
              runHook preCheck
              HOME="$PWD"
              dub test --combined --skip-registry=all
              runHook postCheck
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out/share/cgi-bin
              cp -r "${targetOf package}" $out/share/cgi-bin
              install -m755 -D $out/share/cgi-bin/spine_search spine_search
              runHook postInstall
            '';
            postInstall = ''
              echo "HERE ${targetOf package} $out/share/cgi-bin"
              echo `ls -la $out/share/cgi-bin/spine_search`
            '';
            meta =
              lib.optionalAttrs (package ? description) {
                description = package.description;
              }
              // attrs.meta or {};
          }
          // lib.optionalAttrs (!(attrs ? version)) {
            name = package.name; # use name from dub.json, unless pname and version are specified
          }));
  }
);
  mkDubDerivation rec {
    name = "spine-search-${version}";
    src = ./.;
    buildInputs = [
      pkgs.sqlite
      (
        with pkgs; [
          nixVersions.unstable #nixFlakes
          ## package manager
          dub
          ## compiler
          ldc
          rund
          sqlite
        ]
      )
    ];
    meta = with pkgs.lib; {
      pname = "spine-search";
      version = "<<spine_version_set>>";
      homepage = "https://sisudoc.org";
      description = "cgi sqlite search form for document object search";
      longDescription = ''
        a sisu like parser & document generator
      '';
      homepage = "https://sisudoc.org";
      license = licenses.agpl3Plus;
      platforms = platforms.linux;
      maintainers = ["RalphAmissah"];
    };
  }
#+END_SRC

- unused
  - installPhase

#+BEGIN_SRC txt
installPhase = ''
  mkdir -p $out/bin
  cp spine $out/bin
  chmod +x $out/bin/spine
'';
#+END_SRC

** variables used SET
*** spine version SET VERSION :version:set:project:

#+NAME: spine_version_set
#+BEGIN_SRC sh
0.12.0
#+END_SRC

*** nixpkgs path / url

- nixpkgs_url_github
- nixpkgs_url_local

**** github (official)

#+NAME: nixpkgs_url_github
#+BEGIN_SRC sh
github:NixOS/nixpkgs/nixpkgs-unstable
#+END_SRC

**** localhost

#+NAME: nixpkgs_url_local
#+BEGIN_SRC sh
/srv/nix/nixpkgs
#+END_SRC

*** nixpkgs path options

- <nixpkgs>

#+NAME: nixpkgs_url
#+HEADER: :noweb yes
#+BEGIN_SRC sh
<<nixpkgs_url_github>>
#+END_SRC

#+NAME: nixpkgs_url_github
#+BEGIN_SRC nix
github:nixos/nixpkgs
#+END_SRC

#+NAME: nixpkgs_path_local
#+BEGIN_SRC nix
/srv/nix/nixpkgs
#+END_SRC