summaryrefslogtreecommitdiffhomepage
path: root/dlang/flake.nix
blob: 7591e8dd351ed1d19186b67b3505c759ea9cf30d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
{
  description = "ocda-lib: the object-centric document abstraction as a D library";
  inputs.nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.zst";
  outputs = { self, nixpkgs }:
    let
      system = "x86_64-linux"; # adjust for aarch64-linux / darwin
      pkgs = import nixpkgs { inherit system; };
      /* A library, so the library itself is not a build product: a program
         that uses it compiles its modules alongside its own, as the writer's
         flake does, or takes it as a dub dependency. What is built here are
         programs over it: the reader, and the two that put the library to
         the question - the agreement check, which loads a document's .ssp
         and its .ocda.db and compares the two models, and the dump, which
         writes a loaded model out canonically so that an implementation in
         another language can be diffed against this one.
         .
         `mains` is what is compiled besides the library: the checks are one
         file each in test/, the reader is src/read/.
      */
      mkTool = { tool, binary, what, mains, compiler, compilerBin }:
        pkgs.stdenv.mkDerivation {
          pname = "ocda-lib-${tool}";
          version = "2.1.0";
          src = self;
          nativeBuildInputs = [ compiler ];
          buildInputs = [ pkgs.sqlite pkgs.zstd ];
          buildPhase = ''
            runHook preBuild
            export HOME=$TMPDIR
            ${compilerBin} -I=src -of=${tool} src/ocda/*.d ${mains} -L-lsqlite3 -L-lzstd
            runHook postBuild
          '';
          installPhase = ''
            runHook preInstall
            mkdir -p $out/bin
            install -m755 ${tool} $out/bin/${binary}
            runHook postInstall
          '';
          meta = {
            description = what;
            mainProgram = binary;
          };
        };
      ldc = { compiler = pkgs.ldc; compilerBin = "ldmd2"; };
      ocda-read = mkTool (ldc // {
        tool = "read"; binary = "ocda-read"; mains = "src/read/*.d";
        what = "reads the abstraction in any of its forms and says what is in it";
      });
      ocda-agree = mkTool (ldc // {
        tool = "agree"; binary = "ocda-agree"; mains = "test/agree.d";
        what = "checks that the .ssp and .ocda.db loaders give one model";
      });
      ocda-dump = mkTool (ldc // {
        tool = "dump"; binary = "ocda-dump"; mains = "test/dump.d";
        what = "writes a loaded abstraction out canonically, as an oracle";
      });
    in {
      packages.${system} = {
        /* All three in one bin/, so that one build leaves every program in
           one result link. Built separately into the same link, each build
           replaced the one before, and a script looking for ocda-dump beside
           ocda-agree found nothing.
        */
        default = pkgs.symlinkJoin {
          name = "ocda-lib-programs-2.1.0";
          paths = [ ocda-read ocda-agree ocda-dump ];
        };
        inherit ocda-read ocda-agree ocda-dump;
      };

      devShells.${system}.default = pkgs.mkShell {
        packages = [ pkgs.ldc pkgs.dub pkgs.dtools pkgs.sqlite pkgs.zstd ];
      };
    };
}