-*- mode: org -*- #+TITLE: configuration nix #+DESCRIPTION: configuration nix #+FILETAGS: :spine:build:tools: #+AUTHOR: Ralph Amissah #+EMAIL: [[mailto:ralph.amissah@gmail.com][ralph.amissah@gmail.com]] #+COPYRIGHT: Copyright (C) 2015 (continuously updated, current 2026) Ralph Amissah #+LANGUAGE: en #+STARTUP: show3levels hideblocks hidestars noindent entitiespretty #+PROPERTY: header-args+ :eval never-export :exports code #+PROPERTY: header-args+ :noweb yes :padline no #+PROPERTY: header-args+ :results silent :cache no #+PROPERTY: header-args+ :mkdirp yes #+OPTIONS: H:3 num:nil toc:t \n:t ::t |:t ^:nil -:t f:t *:t - magic single double-quote → " ← FIX changes hilighting behavior (occuring after it) in org document. INVESTIGATE (org-mode CONFIG?) FIND & FIX * ./ ** README.md #+HEADER: :tangle ../README.md #+HEADER: :noweb yes #+BEGIN_SRC md # sisudoc-ocda-lib The **object-centric document abstraction as a library**: the model, and loaders for both of the forms it is written in. **One reader per language, in a directory named for the language.** | | | |--------------------|---------| | [`dlang/`](dlang/) | D | | [`gleam/`](gleam/) | Gleam | | `ruby/` | to come | ## What it is for The readers in `sisudoc-ssp-reader` and `sisudoc-ocda-db-reader` each read one serialisation and print. A **writer** needs neither: it needs the document. ``` .ssp ─┐ ├─> the model ─> a writer .ocda.db ─┘ ``` So this library holds the model and both loaders, and **a writer cannot tell which serialisation it was handed** - exactly as spine's own writers cannot, since spine 0.25.0. That is the whole of the idea. The writers are functions from the model to bytes, and the reader is a program over the model. ## The reader ```sh ocda-read [--tree|--html|--llm-text|--llm-jsonl|--images|--verify --image-dir=| --languages|--files|--report-unknown|--validate] .ssp | .ocda.db | .sisupod [lang] ``` One reader, in each language, where `sisudoc-ssp-reader` and `sisudoc-ocda-db-reader` were two, each with a parser of its own. Built on this library, **every mode reads every form and says the same thing of a document's `.ssp`, `.ocda.db` and `.sisupod`**, 36 of 36 document-languages. The D reader has every mode of both old readers; the Gleam one the modes the Gleam readers had (the summary, `--tree`, `--languages`, `--files`, `--report-unknown`), and in those **its output is the D one's, byte for byte**, 36 of 36. It is in each language's `src/read/`, and not part of the library: a program using the library does not build it (in D, by dub configuration; in Gleam a dependant compiles it and does not use it, Gleam building everything in `src/`). Writing it found one defect in the library: **the database loader could not say what it had not understood**. It asks for columns by name, and so never saw the ones it did not ask for, and reported that it had understood everything. It now counts them on the conditions under which the `.ssp` writes the same property, and the report is the same from either form. ## The checks that matter The claim above is only true if the loaders agree, so the library asks. Two programs, in each language: ```sh ocda-agree .ssp .ocda.db [lang] # do the two loaders agree? ocda-dump .ssp|.ocda.db [lang] # the whole model, canonically ``` `agree` compares two models within one language. **`dump` is the stronger of the two**, and the reason it exists: it writes the entire loaded model out in a fully determined form, and the D and the Gleam library write it *byte for byte alike*. So four questions can be asked, all of them with `diff`: | | | |-----------------------------|---------------------------------| | D: `.ssp` == `.ocda.db` | **36 of 36** document-languages | | Gleam: `.ssp` == `.ocda.db` | **36 of 36** | | `.ssp`: D == Gleam | **36 of 36** | | `.ocda.db`: D == Gleam | **36 of 36** | None of those held at first. ## What the checks found ### the ten-field check: a blank first text line An object whose **first text line is blank** lost it. The loader decided whether to start a new line by asking whether the accumulated text was empty, which is not the same question as whether a line has been seen. Of the sample collection **seven documents have verse opening on a blank line**, and in every one of them the blank was dropped. Eight of thirty-six documents disagreed. Nothing else had caught it. The two `.ssp` readers had been compared on *section counts*, which this does not change. It took loading the same document two ways and comparing the objects. Fixed here and in `sisudoc-ssp-reader/dlang`, which carried the same code. ### the whole-model dump: four more The ten-field check was enough for that and not enough for anything subtler. Dumping the whole model found four further disagreements between the two loaders: 1. **`.identifier` and `.anchor`.** The `.ssp` emits a property only when it carries information, so the identifier is absent when it is simply the ocn and the anchor is absent when it is the segment name; the database stores both unconditionally. Over one document that is **1,314 identifiers and 69 anchors**. The loaders now derive them, which is what the model means. 2. **`make` and `doc_has`.** The database has one metadata table where the text form has three blocks, and tells them apart by a key prefix. The loaders unprefix them, so a writer asks `make["footer"]` whichever serialisation it was handed. 3. **The JSON columns were scanned rather than parsed.** Phobos writes `/` as `\/`, so every heading containing a slash came back with a backslash in it: **all 36 document-languages** differed on `heading_ancestors_text` and nothing else had shown it. 4. **`translation.ocn_aligned`** is in the database and cannot be in a `.ssp`, which is one language and cannot know whether the languages share a numbering. It is a fact about the *file*, so the loaders leave it out rather than letting a writer tell which serialisation it was given. The first three are defects. The fourth is a real asymmetry between the two serialisations, and naming it is the useful part. ## What it reads, and what it does not | | | | |-----------------------|------------------------------------------------------------------|-------------------| | `.ssp` | yes | | | `.ocda.db` | yes, any language of it | | | `.sisupod` | yes, any language it carries | D only, see below | | `.zip` pod | yes, any language it carries | | | `.sst`, `.ssm` markup | **no, and not planned**: that is a parser, which is spine's work | | | a url | no | | A pod carries the abstraction only when spine was asked for it: `--pod2` puts it in, `--source` does not. A pod without one is refused with a message saying which flag makes a pod this library can read, because that is a fact about the pod rather than about the library. **Over the reference collection, a `.sisupod` gives the same model as the `.ssp` beside it: 36 of 36 document-languages, byte identical dumps.** A writer over the library therefore gained a third input form without being touched, which is the point of the dispatch being in one place. ### the one thing the Gleam library cannot do A `.sisupod` is **one zstd frame wrapping** the zip. The D library reads both through a declared `libzstd`. The Gleam library reads the **zip and not the frame**, because the only zstd on the BEAM is a NIF that clones zstd from github in its own build and so cannot be built in a sandbox without patching it. So a `.zip` pod is read in both languages, a `.sisupod` in D only, and the Gleam refusal says why and says `zstd -d` rather than claiming the file is malformed. It is a packaging limit, not anything about the format, and it is the only place the two libraries differ in what they accept. `ocda/load` is the one place in each language that decides what a path is, so a new input form is added once and every reader and writer gains it. ## The format Specified in **sisudoc-abstraction-format**: `ocda-model.md` for the model this library implements, and the two format specifications for the loaders. Section 4 of `ocda-db-format-specification.md` gives the column by column correspondence the `load_db` of each language follows. At format **2.x**. #+END_SRC ** git .gitignore :gitignore: #+HEADER: :tangle "../.gitignore" #+BEGIN_SRC gitignore # git ls-files --others --exclude-from=.git/info/exclude # git ls-files --others --ignored --exclude-standard --directory # git check-ignore -v flake.lock # git clean -ix # find . -name "*_" | xargs rm -rf # find . -name "*.o" | xargs rm -rf # Deny everything, then whitelist what belongs in the repository. # # The practice is deliberate: a repository should hold what was decided to # put in it, not whatever happened to be in the directory when someone ran # "git add .". Build output, editor droppings, downloaded dependencies and # exported binaries are numerous, are regenerated, and differ between # machines; source is few and is chosen. So the default is no, and every # yes below is a decision that can be read. # # To see what is being excluded, and why: # git status --ignored # git check-ignore -v # git ls-files --others --ignored --exclude-standard --directory * # ── the repository itself ──────────────────────────────────────────────── !.gitignore !README.md !LICENSE # ── directories have to be walked into before a file inside can match ──── !*/ # but not these, whatever they contain build/ .build/ .direnv/ .gleam/ bin/ result result-* # ── documentation and notes, in any language directory ─────────────────── !**/*.md !**/*.org # ── nix ────────────────────────────────────────────────────────────────── !**/*.nix !**/flake.lock !**/.envrc # ── dlang ──────────────────────────────────────────────────────────────── !**/*.d !**/dub.json !**/dub.sdl !**/dub.selections.json *.o *.a *.lst # ── gleam ──────────────────────────────────────────────────────────────── !**/*.gleam # Erlang, for what Gleam reaches through FFI (a sha256, from OTP crypto) !**/src/*.erl # gleam.toml is the manifest, manifest.toml is the lockfile: both belong !**/*.toml *.beam *.ez erl_crash.dump # ── ruby, when it arrives ──────────────────────────────────────────────── !**/*.rb !**/Gemfile !**/Gemfile.lock !**/*.gemspec # ── continuous integration ─────────────────────────────────────────────── !**/*.yml !**/*.yaml #+END_SRC * ./dlang ** nix flake.nix :flake: #+HEADER: :tangle ../dlang/flake.nix #+HEADER: :noweb yes #+BEGIN_SRC nix { description = "ocda-lib: the object-centric document abstraction as a D library"; inputs.nixpkgs.url = "<>"; 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 = "0.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-0.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 ]; }; }; } #+END_SRC ** README.md #+HEADER: :tangle ../dlang/README.md #+HEADER: :noweb yes #+BEGIN_SRC md # ocda-lib, in D The abstraction's model and both its loaders, as a dub library. ## Modules | | | |---|---| | `ocda.model` | the document, the object, the eight sections. Imports nothing | | `ocda.load_ssp` | text -> model | | `ocda.load_db` | sqlite -> model | | `ocda.load` | what a path is, and loading it | | `ocda.inventory` | what a file holds beyond the one document: its languages (every form alike), and what a `.ocda.db` carries | | `ocda.dump` | the model written out canonically, as an oracle | | `ocda.sqlite` | the sqlite3 C API, declared rather than depended upon | | `read.*` | `ocda-read`, the reader: in `src/read/`, and *not* part of the library (below) | `ocda.model` importing nothing is the property that matters: a writer depends on the model and on neither loader. ## Use ```json "dependencies": { "ocda-lib": { "path": "../../sisudoc-ocda-lib/dlang" } } ``` ```d import ocda.load; auto doc = load("document.ocda.db", "de"); // or "document.ssp" foreach (obj; doc.body) { ... } ``` Link `sqlite3`; the library declares the dozen functions it needs rather than taking a binding from the registry, so there is nothing to fetch. ## The reader ```sh nix build .#ocda-read && ./result/bin/ocda-read [--tree|--html|--llm-text|--llm-jsonl| --images|--verify --image-dir=|--languages|--files|--report-unknown|--validate] .ssp|.ocda.db|.sisupod [lang] ``` The library's reader, one program where `sisudoc-ssp-reader` and `sisudoc-ocda-db-reader` were two. Its output modules are the `.ssp` reader's, moved onto the library's model, so every mode reads every form and **says the same thing of a document's `.ssp`, `.ocda.db` and `.sisupod`**. `--files` answers for a `.ocda.db`, the one form that carries files; `--validate` checks a `.ssp` as text and refuses anything else. It lives in `src/read/` beside the library, and dub keeps it out of the library: the configuration `library` excludes `src/read/*`, the configuration `ocda-read` builds it. A program using the library by dub, or by naming `src/ocda/*.d` as the writer's flake does, never compiles it. ## The two checks ```sh nix build .#ocda-agree && ./result/bin/ocda-agree .ssp .ocda.db [lang] nix build .#ocda-dump && ./result/bin/ocda-dump [--unknown] [lang] ``` `agree` loads both and compares ten fields of each object, naming the field where they part company. `agree` found the blank-first-text-line defect and was not enough for anything subtler. **`ocda-dump` is the stronger check**: the whole loaded model, every field, written out in a form fully determined by the model, so that two implementations can be compared with `diff`. It is an oracle, not an output format; anything reading it to reconstruct a document has misunderstood it. It agrees byte for byte with the Gleam library's `ocda-lib dump`, which is the point of having it. It found four disagreements `agree` could not see. They are in the repository README and in the history. ## Build ```sh nix build # all three programs, in one result/bin nix build .#ocda-read # the reader nix build .#ocda-agree # the agreement check nix build .#ocda-dump # the canonical dump nix develop # ldc, dub, dtools, sqlite, zstd dub build # the library dub build --config=ocda-read # the reader ``` #+END_SRC ** dub.json #+HEADER: :tangle ../dlang/dub.json #+HEADER: :noweb yes #+BEGIN_SRC json { "authors": [ "Ralph Amissah" ], "copyright": "Copyright (C) 2026 Ralph Amissah", "name": "ocda-lib", "version": "0.1.0", "description": "the object-centric document abstraction as a library: the model, and loaders for its two serialisations", "homepage": "https://sisudoc.org", "license": "AGPL-3.0+", "sourcePaths": [ "./src" ], "importPaths": [ "./src" ], "libs": [ "sqlite3", "zstd" ], "configurations": [ { "name": "library", "targetType": "library", "excludedSourceFiles": [ "src/read/*" ] }, { "name": "ocda-read", "targetType": "executable", "targetName": "ocda-read", "mainSourceFile": "src/read/main.d" } ] } #+END_SRC * ./gleam ** nix flake.nix :flake: #+HEADER: :tangle ../gleam/flake.nix #+HEADER: :noweb yes #+BEGIN_SRC nix { description = "ocda-lib: the object-centric document abstraction as a Gleam library"; inputs.nixpkgs.url = "<>"; outputs = { self, nixpkgs }: let system = "x86_64-linux"; # adjust for aarch64-linux / darwin pkgs = import nixpkgs { inherit system; }; name = "ocda_lib"; /* rebar3 with the port compiler already in it. esqlite builds a NIF, and its rebar3 configuration asks for the `pc` plugin, which rebar3 would otherwise fetch from Hex at build time: impossible in a sandbox, and the build fails with "missing_package pc". nixpkgs carries the plugin, so the answer is a rebar3 that has it before it starts. */ rebar3-pc = pkgs.beamPackages.rebar3WithPlugins { plugins = [ pkgs.beamPackages.pc ]; }; /* The Hex dependencies, as manifest.toml pins them. . There is no Gleam builder in nixpkgs and `gleam build` fetches from Hex, so a sandboxed build cannot reach them. A fixed output derivation may, because its result is pinned by hash. . When a dependency changes, manifest.toml changes and this hash must change with it: build, take the hash nix reports, put it here. */ deps = pkgs.stdenv.mkDerivation { pname = "${name}-deps"; version = "0.1.0"; src = ./.; nativeBuildInputs = [ pkgs.gleam pkgs.cacert ]; buildPhase = '' export HOME=$TMPDIR gleam deps download ''; installPhase = '' mkdir -p $out cp -r build/packages/* $out/ ''; dontFixup = true; outputHashMode = "recursive"; outputHashAlgo = "sha256"; outputHash = "sha256-nWU753YRsC28gsaGyy+A3aZaWf15ctULYiUlvsfyB1c="; }; in { packages.${system} = { default = self.packages.${system}.${name}; /* Shipped as an Erlang shipment rather than as an escript, because sqlite on the BEAM is a NIF: esqlite compiles its own sqlite into a shared object, and a NIF cannot be loaded from inside an escript archive, the runtime needing a real file on disk. The shipment keeps priv/ on disk, so it loads. */ ${name} = pkgs.stdenv.mkDerivation { pname = "ocda-lib"; version = "0.1.0"; src = ./.; nativeBuildInputs = [ pkgs.gleam pkgs.erlang rebar3-pc pkgs.makeWrapper ]; buildPhase = '' runHook preBuild export HOME=$TMPDIR # the dependencies, in place of the fetch gleam would do mkdir -p build/packages cp -r ${deps}/* build/packages/ chmod -R u+w build/packages gleam export erlang-shipment runHook postBuild ''; installPhase = '' runHook preInstall mkdir -p $out/lib $out/bin cp -r build/erlang-shipment $out/lib/${name} makeWrapper $out/lib/${name}/entrypoint.sh $out/bin/ocda-lib \ --add-flags run \ --prefix PATH : ${pkgs.lib.makeBinPath [ pkgs.erlang pkgs.coreutils ]} # the reader under its own name, as the D flake installs it makeWrapper $out/lib/${name}/entrypoint.sh $out/bin/ocda-read \ --add-flags "run read" \ --prefix PATH : ${pkgs.lib.makeBinPath [ pkgs.erlang pkgs.coreutils ]} runHook postInstall ''; meta = { description = "the abstraction as a Gleam library, with its reader, dump and agreement check"; mainProgram = "ocda-lib"; }; }; }; devShells.${system}.default = pkgs.mkShell { packages = [ pkgs.gleam pkgs.erlang pkgs.rebar3 pkgs.sqlite ]; }; }; } #+END_SRC ** README.md #+HEADER: :tangle ../gleam/README.md #+HEADER: :noweb yes #+BEGIN_SRC md # ocda-lib, in Gleam The abstraction's model and both its loaders, as a Gleam library, with its reader and the two programs that put it to the question. | | | |------------------|-----------------------------------------------------------------------------------------| | `ocda/model` | the document, the object, the image. Depends on nothing but the standard library | | `ocda/load_ssp` | text -> model | | `ocda/load_db` | sqlite -> model | | `ocda/load` | what a path is, and loading it | | `ocda/inventory` | what a file holds beyond the one document: its languages, and what a `.ocda.db` carries | | `ocda/dump` | the model written out canonically, as an oracle | | `read/main` | `ocda-read`, the reader | | `ocda_ffi.erl` | a sha256, from OTP's crypto, which the standard library lacks | ## Use ```gleam import ocda/load import ocda/model case load.load(path, "en", False) { Error(why) -> io.println_error(why) Ok(doc) -> { // and from here a writer neither knows nor cares which of the two // files it was handed list.each(model.section(doc, "body"), fn(obj) { ... }) } } ``` ## The reader ```sh nix build ./result/bin/ocda-read [--tree|--outline|--languages|--files|--report-unknown] .ssp|.ocda.db|.zip [lang] ``` `ocda-lib read`, installed also as `ocda-read`. The modes the Gleam readers had, over the library, so each reads every form this library reads; the others are the D reader's. **Its output is the D `ocda-read`'s, byte for byte**, in every mode both have. In `src/read/`, because Gleam compiles nothing outside `src/`; a program depending on the library compiles it too, and does not use it. A `.sisupod` it refuses, saying why: the zstd frame, below. ## The two programs ```sh nix build ./result/bin/ocda-lib agree .ssp .ocda.db [lang] ./result/bin/ocda-lib dump [--unknown] .ssp|.ocda.db [lang] ``` `agree` asks whether the two loaders give the same model. `dump` writes the whole model out canonically, and is the stronger check of the two, because it is **byte for byte what the D library's `ocda-dump` writes**. So the four questions can all be asked with `diff`: | | | |-----------------------------|-----------------------------| | D: `.ssp` == `.ocda.db` | 36 of 36 document-languages | | Gleam: `.ssp` == `.ocda.db` | 36 of 36 | | `.ssp`: D == Gleam | 36 of 36 | | `.ocda.db`: D == Gleam | 36 of 36 | ## Deliberately a mirror of the D library Field for field, name for name, including where that is not the most Gleamish choice: - `text` is one `String` with the lines joined by newline, not a `List(String)`. So an object whose only text line is blank is indistinguishable from an object with no text, *in both languages, in the same place*. A difference that existed in one and not the other would be worse than a loss both share, because it would show up in every dump and mean nothing. - the properties are typed fields rather than a list of pairs. A writer wants `obj.parent_ocn`, not a lookup that might miss. The point is that the two agree. Making them agree is much cheaper when they are shaped alike, and the shape is the specification's, not either language's. ## What the agreement found Four disagreements, none of which a comparison of section counts or of a handful of fields would have shown. All four are recorded in the D library's history; the short version: 1. `.identifier` and `.anchor` are omitted by the text form when they can be worked out (the identifier is the ocn, the anchor is the segment). Both loaders now derive them. Over one document that is 1,314 identifiers. 2. `make` and `doc_has` are one metadata table in the database, distinguished by a key prefix. Both loaders unprefix them. 3. The JSON columns must be *parsed*, not scanned: the encoder writes `/` as `\/` and every heading with a slash in it came back wrong. 4. `translation.ocn_aligned` is in the database and cannot be in a `.ssp`, which is one language. It is a fact about the file, so neither loader puts it in the document. ## Build ```sh nix build # sandboxed, no network nix develop -c gleam test ``` Shipped as an Erlang shipment rather than an escript, because sqlite on the BEAM is a NIF and a NIF cannot be loaded from inside an escript archive. The dependency hash in `flake.nix` pins what `manifest.toml` pins; change one and the other must change with it. ## Format Specified in **sisudoc-abstraction-format**: `ocda-model.org` for the model, `ssp-format-specification.org` and `ocda-db-format-specification.org` for the two serialisations. At format **2.x**. #+END_SRC ** gleam.toml #+HEADER: :tangle ../gleam/gleam.toml #+HEADER: :noweb yes #+BEGIN_SRC toml name = "ocda_lib" version = "0.1.0" description = "the object-centric document abstraction as a library: the model, and loaders for its two serialisations" licences = ["AGPL-3.0-or-later"] [dependencies] gleam_stdlib = ">= 1.0.0 and < 2.0.0" argv = ">= 1.1.0 and < 2.0.0" simplifile = ">= 2.7.0 and < 3.0.0" sqlight = ">= 1.0.0 and < 2.0.0" gleam_json = ">= 3.0.0 and < 4.0.0" [dev-dependencies] gleeunit = ">= 1.0.0 and < 2.0.0" #+END_SRC * versions GET ** dlang overlays *** ldc #+NAME: ldc_version #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./nix-develop-dlang-shared.org:ldc-version()>> #+END_SRC *** dmd #+NAME: dmd_version #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./nix-develop-dlang-shared.org:dmd-version()>> #+END_SRC *** dub #+NAME: dub_version #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./nix-develop-dlang-shared.org:dub-version()>> #+END_SRC *** dtools #+NAME: dtools_version #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./nix-develop-dlang-shared.org:dtools-version()>> #+END_SRC ** sha256 blank hash #+NAME: sha256-blank #+BEGIN_SRC nix <<./nix-develop-dlang-shared.org:sha256-blank()>> #+END_SRC #+NAME: blank_hash #+BEGIN_SRC nix <<./nix-develop-dlang-shared.org:sha256-blank()>> #+END_SRC * org includes ** spine project VERSION #+NAME: spine_version #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./sisudoc_spine_version_info_and_doc_header_including_copyright_and_license.org:spine_project_version()>> #+END_SRC ** year #+NAME: year #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./sisudoc_spine_version_info_and_doc_header_including_copyright_and_license.org:year()>> #+END_SRC ** document header including copyright & license #+NAME: doc_header_including_copyright_and_license #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./sisudoc_spine_version_info_and_doc_header_including_copyright_and_license.org:spine_doc_header_including_copyright_and_license()>> #+END_SRC * nixpkgs source #+NAME: nixpkgs_unstable #+HEADER: :noweb yes #+BEGIN_SRC emacs-lisp <<./sisudoc_spine_version_info_and_doc_header_including_copyright_and_license.org:nixpkgs_unstable()>> #+END_SRC * __END__