module ocda.load; /+ ↓ what a path is, and loading it. . One place that decides, so that every reader and every writer accepts the same inputs and a new input type is added once. This mirrors spine's own ocda/abstraction/load.d, which names the sources it can enter the pipeline from and tells them apart by suffix. . Deliberately *not* here: .sst and .ssm markup. Reading markup means implementing the parser, which is spine's work and a far larger thing than a reader or a sample writer needs. This library reads abstractions. +/ import std.algorithm : endsWith; import ocda.model; import ocda.load_ssp; import ocda.load_db; import ocda.load_pod; enum Source { ssp, // .ssp, the abstraction as text ocda_db, // .ocda.db, the abstraction as sqlite pod, // .sisupod or .zip, an archive carrying a .ssp unknown, } Source sourceOf(string path) { if (path.endsWith(".ocda.db")) { return Source.ocda_db; } if (path.endsWith(".ssp")) { return Source.ssp; } /+ ↓ .sisupod is the archive spine writes now; .zip is what it wrote before, and every pod already published carries that name, so both are read. What is inside decides how it is opened, not the name. +/ if (path.endsWith(".sisupod")) { return Source.pod; } if (path.endsWith(".zip")) { return Source.pod; } if (path.endsWith(".db")) { return Source.ocda_db; } return Source.unknown; } string sourceName(Source s) { final switch (s) { case Source.ssp: return ".ssp (the abstraction as text)"; case Source.ocda_db: return ".ocda.db (the abstraction as sqlite)"; case Source.pod: return "a pod archive carrying a .ssp"; case Source.unknown: return "not an abstraction this library reads"; } } class OcdaLoadError : Exception { this(string msg) { super(msg); } } /+ ↓ load whatever the path is into the model. lang names which language to take from a .ocda.db, which holds every language of its document, and from a pod, which may carry more than one .ssp. A .ssp is one language by construction and ignores it. +/ OcdaDocument load(string path, string lang = "", bool any_version = false) { final switch (sourceOf(path)) { case Source.ssp: return parseSspFile(path); case Source.ocda_db: return loadDbFile(path, lang, any_version); case Source.pod: return loadPodFile(path, lang); case Source.unknown: throw new OcdaLoadError(path ~ ": " ~ sourceName(Source.unknown) ~ " (expected .ssp, .ocda.db, .sisupod or .zip)"); } }