factor out nix code into new files via makeScope

This makes the Nix code a lot easier to reason about.

nix/pkgs/book/default.nix

@@ -0,0 +1,34 @@
+# Keep sorted
+{ default
+, inputs
+, mdbook
+, stdenv
+}:
+
+stdenv.mkDerivation {
+  pname = "${default.pname}-book";
+  version = default.version;
+
+
+  src = let filter = inputs.nix-filter.lib; in filter {
+    root = inputs.self;
+
+    # Keep sorted
+    include = [
+      "book.toml"
+      "conduit-example.toml"
+      "debian/README.md"
+      "docs"
+      "README.md"
+    ];
+  };
+
+  nativeBuildInputs = [
+    mdbook
+  ];
+
+  buildPhase = ''
+    mdbook build
+    mv public $out
+  '';
+}

nix/pkgs/default/cross-compilation-env.nix

@@ -0,0 +1,100 @@
+{ lib
+, pkgsBuildHost
+, rust
+, stdenv
+}:
+
+lib.optionalAttrs stdenv.hostPlatform.isStatic {
+  ROCKSDB_STATIC = "";
+}
+//
+{
+  CARGO_BUILD_RUSTFLAGS =
+    lib.concatStringsSep
+      " "
+      ([]
+        # This disables PIE for static builds, which isn't great in terms of
+        # security. Unfortunately, my hand is forced because nixpkgs'
+        # `libstdc++.a` is built without `-fPIE`, which precludes us from
+        # leaving PIE enabled.
+        ++ lib.optionals
+          stdenv.hostPlatform.isStatic
+          [ "-C" "relocation-model=static" ]
+        ++ lib.optionals
+          (stdenv.buildPlatform.config != stdenv.hostPlatform.config)
+          [ "-l" "c" ]
+        ++ lib.optionals
+          # This check has to match the one [here][0]. We only need to set
+          # these flags when using a different linker. Don't ask me why, though,
+          # because I don't know. All I know is it breaks otherwise.
+          #
+          # [0]: https://github.com/NixOS/nixpkgs/blob/5cdb38bb16c6d0a38779db14fcc766bc1b2394d6/pkgs/build-support/rust/lib/default.nix#L37-L40
+          (
+            # Nixpkgs doesn't check for x86_64 here but we do, because I
+            # observed a failure building statically for x86_64 without
+            # including it here. Linkers are weird.
+            (stdenv.hostPlatform.isAarch64 || stdenv.hostPlatform.isx86_64)
+              && stdenv.hostPlatform.isStatic
+              && !stdenv.isDarwin
+              && !stdenv.cc.bintools.isLLVM
+          )
+          [
+            "-l"
+            "stdc++"
+            "-L"
+            "${stdenv.cc.cc.lib}/${stdenv.hostPlatform.config}/lib"
+          ]
+      );
+}
+
+# What follows is stolen from [here][0]. Its purpose is to properly configure
+# compilers and linkers for various stages of the build, and even covers the
+# case of build scripts that need native code compiled and run on the build
+# platform (I think).
+#
+# [0]: https://github.com/NixOS/nixpkgs/blob/5cdb38bb16c6d0a38779db14fcc766bc1b2394d6/pkgs/build-support/rust/lib/default.nix#L57-L80
+//
+(
+  let
+    inherit (rust.lib) envVars;
+  in
+  lib.optionalAttrs
+    (stdenv.targetPlatform.rust.rustcTarget
+      != stdenv.hostPlatform.rust.rustcTarget)
+    (
+      let
+        inherit (stdenv.targetPlatform.rust) cargoEnvVarTarget;
+      in
+      {
+        "CC_${cargoEnvVarTarget}" = envVars.ccForTarget;
+        "CXX_${cargoEnvVarTarget}" = envVars.cxxForTarget;
+        "CARGO_TARGET_${cargoEnvVarTarget}_LINKER" =
+          envVars.linkerForTarget;
+      }
+    )
+  //
+  (
+    let
+      inherit (stdenv.hostPlatform.rust) cargoEnvVarTarget rustcTarget;
+    in
+    {
+      "CC_${cargoEnvVarTarget}" = envVars.ccForHost;
+      "CXX_${cargoEnvVarTarget}" = envVars.cxxForHost;
+      "CARGO_TARGET_${cargoEnvVarTarget}_LINKER" = envVars.linkerForHost;
+      CARGO_BUILD_TARGET = rustcTarget;
+    }
+  )
+  //
+  (
+    let
+      inherit (stdenv.buildPlatform.rust) cargoEnvVarTarget;
+    in
+    {
+      "CC_${cargoEnvVarTarget}" = envVars.ccForBuild;
+      "CXX_${cargoEnvVarTarget}" = envVars.cxxForBuild;
+      "CARGO_TARGET_${cargoEnvVarTarget}_LINKER" = envVars.linkerForBuild;
+      HOST_CC = "${pkgsBuildHost.stdenv.cc}/bin/cc";
+      HOST_CXX = "${pkgsBuildHost.stdenv.cc}/bin/c++";
+    }
+  )
+)

nix/pkgs/default/default.nix

@@ -0,0 +1,64 @@
+# Keep sorted
+{ craneLib
+, inputs
+, lib
+, pkgsBuildHost
+, rocksdb
+, rust
+, stdenv
+}:
+
+let
+  env = {
+    CONDUIT_VERSION_EXTRA = inputs.self.shortRev or inputs.self.dirtyShortRev;
+    ROCKSDB_INCLUDE_DIR = "${rocksdb}/include";
+    ROCKSDB_LIB_DIR = "${rocksdb}/lib";
+  }
+  //
+  (import ./cross-compilation-env.nix {
+    # Keep sorted
+    inherit
+      lib
+      pkgsBuildHost
+      rust
+      stdenv;
+  });
+in
+
+craneLib.buildPackage rec {
+  inherit
+    (craneLib.crateNameFromCargoToml {
+      cargoToml = "${inputs.self}/Cargo.toml";
+    })
+    pname
+    version;
+
+  src = let filter = inputs.nix-filter.lib; in filter {
+    root = inputs.self;
+
+    # Keep sorted
+    include = [
+      "Cargo.lock"
+      "Cargo.toml"
+      "src"
+    ];
+  };
+
+  # This is redundant with CI
+  doCheck = false;
+
+  nativeBuildInputs = [
+    # bindgen needs the build platform's libclang. Apparently due to "splicing
+    # weirdness", pkgs.rustPlatform.bindgenHook on its own doesn't quite do the
+    # right thing here.
+    pkgsBuildHost.rustPlatform.bindgenHook
+  ];
+
+  inherit env;
+
+  passthru = {
+    inherit env;
+  };
+
+  meta.mainProgram = pname;
+}

nix/pkgs/oci-image/default.nix

@@ -0,0 +1,25 @@
+# Keep sorted
+{ default
+, dockerTools
+, lib
+, tini
+}:
+
+dockerTools.buildImage {
+  name = default.pname;
+  tag = "next";
+  copyToRoot = [
+    dockerTools.caCertificates
+  ];
+  config = {
+    # Use the `tini` init system so that signals (e.g. ctrl+c/SIGINT)
+    # are handled as expected
+    Entrypoint = [
+      "${lib.getExe' tini "tini"}"
+      "--"
+    ];
+    Cmd = [
+      "${lib.getExe default}"
+    ];
+  };
+}