Commit: 47a6efbebc0ef1cd9aa5f6d6fe509b52ba295bae - medialist-cli (git)

CLI interface to medialist (fossil mirror)

Commit MetaInfo

• Révision: 47a6efbebc0ef1cd9aa5f6d6fe509b52ba295bae (tree)
• l'heure: 2023-03-28 16:12:03
• Auteur: mio <stigma@disr...>
• Commiter: mio

Message de Log

Update mlib

FossilOrigin-Name: 78c7e26f7d9b54bd742ff35fe98afb936c56386e8a5e653c3d804ce24485dfc7

Change Summary

• add: mlib/LICENSE
• add: mlib/README
• modified: mlib/dub.sdl
• modified: mlib/source/mlib/cni.d
• add: mlib/source/mlib/configparser.d
• modified: mlib/source/mlib/directories.d
• add: mlib/source/mlib/package.d
• modified: mlib/source/mlib/trash.d
• modified: update_deps.sh

Modification

--- /dev/null
+++ b/mlib/LICENSE
@@ -0,0 +1,13 @@
+Zero-Clause BSD
+===============
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
+FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
+DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

--- /dev/null
+++ b/mlib/README
@@ -0,0 +1,44 @@
+... a collection of personal modules for the D Programming Language.
+
+This file was last updated 11. March 2023
+
+There files here are just the ones that I'm commonly copying from one of my
+projects to another.  The purpose is more to provide a central location that
+I can keep the files updated while making it easier for myself to update them
+in my various projects.
+
+
+
+	CONFIGPARSER
+
+The configparser module will simply parse a INI-like file and provide a 
+simple API to access the various settings within the parsed file.  The
+API isn't complete yet.
+
+
+
+	CNI
+
+The replacement of CONFIGPARSER that has been used in the medialist-cli project.
+While very similar in concept to an INI file, CNI has a defined specification,
+https://github.com/libuconf/cni.
+
+
+
+	DIRECTORIES
+
+Contains a simple API for retrieving the "common directories" for your operating
+system.  For example, on Linux (and most other POSIX systems) DIRECTORIES will
+use the XDG Base Directory Specification.
+
+* This module only compiles under 'Posix' as defined by the D compiler.
+
+
+	TRASH
+
+While this could be an extension on to DIRECTORIES, I chose to keep it separate
+since the specifications they follow are different enough.  In short, this
+module will utilise your operating systems "Recycle Bin" concept rather than
+simple purging the file from existance.
+
+* This module only compiles under 'Posix' as defined by the D compiler.

--- a/mlib/dub.sdl
+++ b/mlib/dub.sdl
@@ -3,4 +3,4 @@ description "A package containing my single-file modules"
 authors "mio"
 license "0BSD"
 
-targetType "library"
+targetType "library"
\ No newline at end of file

--- a/mlib/source/mlib/cni.d
+++ b/mlib/source/mlib/cni.d
@@ -208,7 +208,7 @@ private:
                 moveForward(1);
             }
 
-            value = app[];
+            value = app.data();
             moveForward(1); // move past ending `
             inRawValue = false;
         } else {

--- /dev/null
+++ b/mlib/source/mlib/configparser.d
@@ -0,0 +1,775 @@
+/*
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is herby granted.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PEFORMANCE OF THIS SOFTWARE.
+ */
+
+
+/**
+ * An incomplete single-file INI parser for D.
+ *
+ * The API should be similar to python's configparse module.  Internally it
+ * uses the standard D associative array.
+ *
+ * Example:
+ * ---
+ * import configparser;
+ *
+ * auto config = new ConfigParser();
+ * // no sections initially
+ * assert(config.sections.length == 0);
+ * // Section names ("Program Settings") are case-sensitive
+ * conf.addSection("Storage Paths");
+ * // Option names ("CONFIG_PATH") are case-insensitive
+ * // (internally, they are all converted to lower-case)
+ * conf.set("Program Settings", "CONFIG_PATH", "/home/user/.local/config");
+ * ---
+ *
+ * Authors: nemophila
+ * Date: 2023-03-19
+ * Homepage: https://osdn.net/users/nemophila/pf/mlib
+ * License: 0BSD
+ * Version: 0.4
+ *
+ * History:
+ *      0.4 Add .write()
+ *      0.3 Fix option values not always being treated as lowercase.
+ *      0.2 Add .getBool()
+ *      0.1 Initial release
+ */
+module mlib.configparser;
+
+private
+{
+    import std.conv : ConvException;
+    import std.stdio : File;
+}
+
+public class DuplicateSectionException : Exception
+{
+    private string m_section;
+
+    this(string section)
+    {
+        string msg = "Section " ~ section ~ " already exists.";
+        m_section = section;
+        super(msg);
+    }
+
+    string section()
+    {
+        return m_section;
+    }
+}
+
+///
+/// An exception that is thrown by a strict parser which indicates
+/// that an option appears twice within any one section.
+///
+public class DuplicateOptionException : Exception
+{
+    private string m_option;
+    private string m_section;
+
+    this(string option, string section)
+    {
+	string msg = "Option " ~ option ~ " in section " ~ section ~
+	    " already exists.";
+	m_option = option;
+	m_section = section;
+	super(msg);
+    }
+
+    string option()
+    {
+	return m_option;
+    }
+
+    string section()
+    {
+	return m_section;
+    }
+}
+
+public class NoSectionException : Exception
+{
+    private string m_section;
+
+    this(string section)
+    {
+        string msg = "Section '" ~ section ~ "' does not exist.";
+        m_section = section;
+        super(msg);
+    }
+
+    string section()
+    {
+        return m_section;
+    }
+}
+
+public class NoOptionException : Exception
+{
+    private string m_section;
+    private string m_option;
+
+    this(string section, string option)
+    {
+        string msg = "Section '" ~ section ~ "' does not have option '" ~
+            option ~ "'.";
+        m_section = section;
+        m_option = option;
+        super(msg);
+    }
+
+    string section() { return m_section; }
+    string option() { return m_option; }
+}
+
+/**
+ * The main configuration parser.
+ */
+public class ConfigParser
+{
+    private char[] m_delimiters;
+    private char[] m_commentPrefixes;
+    private bool m_strict;
+
+    /** current section for parsing */
+    private string m_currentSection;
+    private string[string][string] m_sections;
+
+    /**
+     * Creates a new instance of ConfigParser.
+     */
+    this(char[] delimiters = ['=', ':'],
+	 char[] commentPrefixes = ['#', ';'],
+	 bool strict = true)
+    {
+        m_delimiters = delimiters;
+        m_commentPrefixes = commentPrefixes;
+	m_strict = strict;
+    }
+
+    /**
+     * Return an array containing the available sections.
+     */
+    string[] sections()
+    {
+        return m_sections.keys();
+    }
+
+    ///
+    unittest
+    {
+        auto conf = new ConfigParser();
+
+        assert(0 == conf.sections().length);
+
+        conf.addSection("Section");
+
+        assert(1 == conf.sections().length);
+    }
+
+    /**
+     * Add a section named `section` to the instance.
+     *
+     * Throws:
+     *   - DuplicateSectionError if a section by the given name already
+     * exists.
+     */
+    void addSection(string section)
+    {
+        if (section in m_sections)
+            throw new DuplicateSectionException(section);
+        m_sections[section] = null;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertNotThrown, assertThrown;
+
+        auto conf = new ConfigParser();
+
+        /* doesn't yet exist */
+        assertNotThrown!DuplicateSectionException(conf.addSection("sample"));
+        /* already exists */
+        assertThrown!DuplicateSectionException(conf.addSection("sample"));
+    }
+
+    /**
+     * Indicates whether the named `section` is present in the configuration.
+     *
+     * Params:
+     *   section = The section to check for in the configuration.
+     *
+     * Returns: `true` if the section exists, `false` otherwise.
+     */
+    bool hasSection(string section)
+    {
+        auto exists = (section in m_sections);
+        return (exists !is null);
+    }
+
+    ///
+    unittest
+    {
+        auto conf = new ConfigParser();
+        conf.addSection("nExt");
+        assert(true == conf.hasSection("nExt"), "Close the world.");
+        assert(false == conf.hasSection("world"), "Open the nExt.");
+    }
+
+    string[] options(string section)
+    {
+        if (false == this.hasSection(section))
+            throw new NoSectionException(section);
+        return m_sections[section].keys();
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertNotThrown, assertThrown;
+
+        auto conf = new ConfigParser();
+
+        conf.addSection("Settings");
+
+        assertNotThrown!NoSectionException(conf.options("Settings"));
+        assertThrown!NoSectionException(conf.options("void"));
+
+        string[] options = conf.options("Settings");
+        assert(0 == options.length, "More keys than we need");
+    }
+
+    bool hasOption(string section, string option)
+    {
+        import std.string : toLower;
+
+        if (false == this.hasSection(section))
+            return false;
+
+        scope lowercaseOption = toLower(option);
+        auto exists = (lowercaseOption in m_sections[section]);
+        return (exists !is null);
+    }
+    /*
+    string[] read(string[] filenames)
+    {
+        return null;
+    }*/
+
+    void read(string filename)
+    {
+        File file = File(filename, "r");
+        scope(exit) { file.close(); }
+        read(file, false);
+    }
+
+    ///
+    unittest
+    {
+        import std.file : remove;
+        import std.stdio : File;
+
+        auto configFile = File("test.conf", "w+");
+        configFile.writeln("[Section 1]");
+        configFile.writeln("key=value");
+        configFile.writeln("\n[Section 2]");
+        configFile.writeln("key2 = value");
+        configFile.close();
+
+        auto conf = new ConfigParser();
+        conf.read("test.conf");
+
+        assert(2 == conf.sections.length, "Incorrect Sections length");
+        assert(true == conf.hasSection("Section 1"),
+               "Config file doesn't have Section 1");
+        assert(true == conf.hasOption("Section 1", "key"),
+               "Config file doesn't have 'key' in 'Section 1'");
+
+        remove("test.conf");
+    }
+
+    /**
+     * Parse a config file.
+     *
+     * Params:
+     *   file = Reference to the file from which to read.
+     *   close = Close the file when finished parsing.
+     */
+    void read(ref File file, bool close = true)
+    {
+        import std.array : array;
+        import std.algorithm.searching : canFind;
+        import std.string : strip;
+
+        scope(exit) { if (close) file.close(); }
+
+        string[] lines = file.byLineCopy.array;
+
+        for (auto i = 0; i < lines.length; i++) {
+            string line = lines[i].strip();
+
+            if (line == "")
+                continue;
+
+            if ('[' == lines[i][0]) {
+                parseSectionHeader(lines[i]);
+            } else if (false == canFind(m_commentPrefixes, lines[i][0])) {
+                parseLine(lines[i]);
+            }
+            /* ignore comments */
+        }
+    }
+
+  /*void readString(string str)
+    {
+    }*/
+
+    /**
+     * Get an `option` value for the named `section`.
+     *
+     * Params:
+     *   section = The section to look for the given `option`.
+     *   option = The option to return the value of
+     *   fallback = Fallback value if the `option` is not found. Can be null.
+     *
+     * Returns:
+     *   - The value for `option` if it is found.
+     *   - `null` if the `option` is not found and `fallback` is not provided.
+     *   - `fallback` if the `option` is not found and `fallback` is provided.
+     *
+     * Throws:
+     *   - NoSectionException if the `section` does not exist and no fallback is provided.
+     *   - NoOptionException if the `option` does not exist and no fallback is provided.
+     */
+    string get(string section, string option)
+    {
+        import std.string : toLower;
+
+        scope lowercaseOption = toLower(option);
+
+        if (false == this.hasSection(section))
+            throw new NoSectionException(section);
+
+        if (false == this.hasOption(section, lowercaseOption))
+            throw new NoOptionException(section, lowercaseOption);
+
+        return m_sections[section][lowercaseOption];
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+        conf.addSection("Section");
+        conf.set("Section", "option", "value");
+
+        assert(conf.get("Section", "option") == "value");
+        assertThrown!NoSectionException(conf.get("section", "option"));
+        assertThrown!NoOptionException(conf.get("Section", "void"));
+    }
+
+    /// Ditto
+    string get(string section, string option, string fallback)
+    {
+        string res = fallback;
+
+        try {
+            res = get(section, option);
+        } catch (NoSectionException e) {
+            return res;
+        } catch (NoOptionException e) {
+            return res;
+        }
+
+        return res;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+        conf.addSection("Section");
+        conf.set("Section", "option", "value");
+
+        assert("value" == conf.get("Section", "option"));
+        assert("fallback" == conf.get("section", "option", "fallback"));
+        assert("fallback" == conf.get("Section", "void", "fallback"));
+
+        /* can use null for fallback */
+        assert(null == conf.get("section", "option", null));
+        assert(null == conf.get("Section", "void", null));
+    }
+
+    /**
+     * A convenience method which casts the value of `option` in `section`
+     * to an integer.
+     *
+     * Params:
+     *   section = The section to look for the given `option`.
+     *   option = The option to return the value for.
+     *   fallback = The fallback value to use if `option` isn't found.
+     *
+     * Returns:
+     *
+     *
+     * Throws:
+     *   - NoSectionFoundException if `section` doesn't exist.
+     *   - NoOptionFoundException if the `section` doesn't contain `option`.
+     *   - ConvException if it failed to parse the value to an int.
+     *   - ConvOverflowException if the value would overflow an int.
+     *
+     * See_Also: get()
+     */
+    int getInt(string section, string option)
+    {
+        import std.conv : parse;
+
+        string res;
+
+        res = get(section, option);
+
+        return parse!int(res);
+    }
+
+    /// Ditto
+    int getInt(string section, string option, int fallback)
+    {
+        int res = fallback;
+
+        try {
+            res = getInt(section, option);
+        } catch (Exception e) {
+            return res;
+        }
+
+        return res;
+    }
+
+    /*
+    double getDouble(string section, string option)
+    {
+    }
+
+    double getDouble(string section, string option, double fallback)
+    {
+    }
+
+    float getFloat(string section, string option)
+    {
+    }
+
+    float getFloat(string section, string option, float fallback)
+    {
+    }*/
+
+    /**
+     * A convenience method which coerces the $(I option) in the
+     * specified $(I section) to a boolean value.
+     *
+     * Note that the accepted values for the option are "1", "yes",
+     * "true", and "on", which cause this method to return `true`, and
+     * "0", "no", "false", and "off", which cause it to return `false`.
+     *
+     * These string values are checked in a case-insensitive manner.
+     *
+     * Params:
+     *   section = The section to look for the given option.
+     *   option = The option to return the value for.
+     *   fallback = The fallback value to use if the option was not found.
+     *
+     * Throws:
+     *   - NoSectionFoundException if `section` doesn't exist.
+     *   - NoOptionFoundException if the `section` doesn't contain `option`.
+     *   - ConvException if any other value was found.
+     */
+    bool getBool(string section, string option)
+    {
+        import std.string : toLower;
+
+        string value = get(section, option);
+
+        switch (value.toLower)
+        {
+        case "1":
+        case "yes":
+        case "true":
+        case "on":
+            return true;
+        case "0":
+        case "no":
+        case "false":
+        case "off":
+            return false;
+        default:
+            throw new ConvException("No valid boolean value found");
+        }
+    }
+
+    /// Ditto
+    bool getBool(string section, string option, bool fallback)
+    {
+        try {
+            return getBool(section, option);
+        } catch (Exception e) {
+            return fallback;
+        }
+    }
+
+    /*
+    string[string] items(string section)
+    {
+    }*/
+
+    /**
+     * Remove the specified `option` from the specified `section`.
+     *
+     * Params:
+     *   section = The section to remove from.
+     *   option = The option to remove from section.
+     *
+     * Retruns:
+     *   `true` if option existed, false otherwise.
+     *
+     * Throws:
+     *  - NoSectionException if the specified section doesn't exist.
+     */
+    bool removeOption(string section, string option)
+    {
+        if ((section in m_sections) is null) {
+            throw new NoSectionException(section);
+        }
+
+        if (option in m_sections[section]) {
+            m_sections[section].remove(option);
+            return true;
+        }
+
+        return false;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+        conf.addSection("Default");
+        conf.set("Default", "exists", "true");
+
+        assertThrown!NoSectionException(conf.removeOption("void", "false"));
+        assert(false == conf.removeOption("Default", "void"));
+        assert(true == conf.removeOption("Default", "exists"));
+    }
+
+    /**
+     * Remove the specified `section` from the config.
+     *
+     * Params:
+     *   section = The section to remove.
+     *
+     * Returns:
+     *   `true` if the section existed, `false` otherwise.
+     */
+    bool removeSection(string section)
+    {
+        if (section in m_sections) {
+            m_sections.remove(section);
+            return true;
+        }
+        return false;
+    }
+
+    ///
+    unittest
+    {
+        auto conf = new ConfigParser();
+        conf.addSection("Exists");
+        assert(false == conf.removeSection("DoesNotExist"));
+        assert(true == conf.removeSection("Exists"));
+    }
+
+    void set(string section, string option, string value)
+    {
+        import std.string : toLower;
+
+        if (false == this.hasSection(section))
+            throw new NoSectionException(section);
+
+        scope lowercaseOption = toLower(option);
+        m_sections[section][lowercaseOption] = value;
+    }
+
+    ///
+    unittest
+    {
+        import std.exception : assertThrown;
+
+        auto conf = new ConfigParser();
+
+        assertThrown!NoSectionException(conf.set("Section", "option",
+            "value"));
+
+        conf.addSection("Section");
+        conf.set("Section", "option", "value");
+        assert(conf.get("Section", "option") == "value");
+    }
+
+    ///
+    /// Write a representation of the configuration to the
+    /// provided *file*.
+    ///
+    /// This representation can be parsed by future calls to
+    /// `read`.  This does **not** close the file after writing.
+    ///
+    /// Params:
+    ///   file = An open file which was opened in text mode.
+    ///   spaceAroundDelimiters = The delimiters between keys and
+    ///                           values are surrounded by spaces.
+    ///
+    /// Note: Comments from the original file are not preserved when
+    ///       writing the configuration back.
+    ///
+    void write(ref File file, bool spaceAroundDelimiters = true)
+    {
+        string del = spaceAroundDelimiters ? " = " : "=";
+    
+        foreach(string section, string[string] options; m_sections) {
+            file.writefln("[%s]", section);
+
+            foreach(string option, string value; options) {
+                file.writefln("%s%s%s", option, del, value);
+            }
+        }
+    }
+
+    ///
+    unittest
+    {
+        import std.file : remove;
+        import std.stdio : File;
+
+        auto writer = new ConfigParser();
+        writer.addSection("general");
+
+        writer.addSection("GUI");
+        writer.set("GUI", "WINDOW_WIDTH", "848");
+        writer.set("GUI", "WINDOW_HEIGHT", "480");
+
+        auto file = File("test.ini", "w+");
+        scope(exit) remove(file.name);
+        writer.write(file);
+
+        file.rewind();
+
+        auto reader = new ConfigParser();
+        reader.read(file);
+
+        assert(reader.hasSection("general"), "reader does not contain general section");
+
+        assert(reader.hasSection("GUI"), "reader does not contain GUI section");
+        assert(reader.get("GUI", "WINDOW_WIDTH") == "848", "reader GUI.WINDOW_WIDTH is not 848");
+        assert(reader.getInt("GUI", "WINDOW_WIDTH") == 848, "reader GUI.WINDOW_WIDTH is not 848 (int)");
+
+        assert(reader.get("GUI", "WINDOW_HEIGHT") == "480", "reader GUI.WINDOW_HEIGHT is not 480");
+        assert(reader.getInt("GUI", "WINDOW_HEIGHT") == 480, "reader GUI.WINDOW_HEIGHT is not 480 (int)");
+    }
+
+  private:
+
+    void parseSectionHeader(ref string line)
+    {
+        import std.array : appender, assocArray;
+
+        auto sectionHeader = appender!string;
+        /* presume that the last character is ] */
+        sectionHeader.reserve(line.length - 1);
+        string popped = line[1 .. $];
+
+        foreach(c; popped) {
+            if (c != ']')
+                sectionHeader.put(c);
+            else
+                break;
+        }
+
+        m_currentSection = sectionHeader.data();
+
+	if (m_currentSection in m_sections && m_strict)
+	    throw new DuplicateSectionException(m_currentSection);
+
+	try {
+	    this.addSection(m_currentSection);
+	} catch (DuplicateSectionException) {
+	}
+    }
+
+    void parseLine(ref string line)
+    {
+	import std.string : indexOfAny, toLower, strip;
+
+        ptrdiff_t idx = line.indexOfAny(m_delimiters);
+        if (-1 == idx) return;
+        string option = line[0 .. idx].dup.strip.toLower;
+        string value = line[idx + 1 .. $].dup.strip;
+
+	if (option in m_sections[m_currentSection] && m_strict)
+	    throw new DuplicateOptionException(option, m_currentSection);
+
+        m_sections[m_currentSection][option] = value;
+    }
+
+    unittest
+    {
+	import std.exception : assertThrown, assertNotThrown;
+	import std.file : remove;
+
+	auto f = File("config.cfg", "w+");
+	f.writeln("[section]");
+	f.writeln("option = value");
+	f.writeln("Option = value");
+	f.close();
+	scope(exit) remove("config.cfg");
+
+	// Duplicate option
+	scope parser = new ConfigParser();
+	assertThrown!DuplicateOptionException(parser.read("config.cfg"));
+
+	// Duplicate section
+	f = File("config.cfg", "w+");
+	f.writeln("[section]");
+	f.writeln("option = value");
+	f.writeln("[section]");
+	f.close();
+
+	assertThrown!DuplicateSectionException(parser.read("config.cfg"));
+
+	// not strict
+	scope relaxedParser = new ConfigParser(['='], [], false);
+
+	assertNotThrown!DuplicateSectionException(relaxedParser.read("config.cfg"));
+	assert(relaxedParser.hasSection("section"));
+
+	f = File("config.cfg", "a+");
+	f.writeln("option = newValue");
+	f.close();
+
+	assertNotThrown!DuplicateOptionException(relaxedParser.read("config.cfg"));
+	assert(relaxedParser.get("section", "option") == "newValue");
+    }
+}

--- a/mlib/source/mlib/directories.d
+++ b/mlib/source/mlib/directories.d
@@ -14,65 +14,1139 @@
 /**
  * This module provides quick & easy access to the common directories
  * for each operating system.  Currently, only POSIX (XDG Base Directory
- * Specification) is supported.  OS X (Standard Directories) and Windows
- * (Known Folder) will be supported at a later date.
+ * Specification) and Windows (Known Folder) are supported.
+ * OS X (Standard Directories) will be supported at a later date.
  *
  * The main goal of this module is to provide a minimal and simple API.
  *
- * API
+ * ## Example
+ *
  * ---
- * enum Directory
- *   {
- *    home,
- *    data,
- *    config,
- *    state,
- *    cache,
- *    runtime
- *   }
+ * import std.stdio : writefln;
+ * import std.path : buildPath;
+ *
+ * import mlib.directories : getProjectDirectories;
+ *
+ * void main(string[] args)
+ * {
+ *     ProjectDirectories projectDirs = getProjectDirectories("org", "Example ORG", "My Program");
+ *     auto config = readConfig(projectDirs.configDir);
+ *
+ *     // ...rest of program
+ * }
+ *
+ * auto readConfig(string path)
+ * {
+ *     // ...some implementation
+ * }
  *
- * DirEntry open(Directory);
  * ---
  *
- * This module supports D version greater than or equal to 2.068.0.
+ *
+ * This module supports D version greater than or equal to 2.076.0.
  *
  * Authors: nemophila
- * Date: February 18, 2023
+ * Date: March 6, 2023
  * Homepage: https://osdn.net/users/nemophila/pf/mlib
- * License: 0BSD
- * Standards: XDG Base Directory Specification 0.8
- * Version: 0.1.0
+ * License: $(LINK2 https://osdn.net/users/nemophila/pf/mlib/scm/blobs/trunk/LICENSE, 0BSD)
+ * Standards:
+ *   $(UL
+ *     $(LI $(LINK2 https://specifications.freedesktop.org/basedir-spec/0.8/, XDG Base Directory Specification 0.8))
+ *     $(LI $(LINK2 https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/bb776911(v=vs.85), Known Folders))
+ *    )
+ * Version: 0.2.0
  *
  * History:
  *      0.X.X was the initial version (June 12, 2021)
  *
  *      0.1.0 adds support for runtime and state (February 18, 2023)
  *
- * Bugs:
- *  - Doesn't support compiling on operating systems other that Posix
- *  - Doesn't check if the environment variable value is empty.
+ *      0.2.0 Re-wrote the API. Now supports Windows. Bump minimum D version to 2.076.0 (March 26, 2023)
  */
 module mlib.directories;
 
 import std.file : DirEntry;
 
+///
+/// Deprecated: Use the new `getBaseDirectories`, `getProjectDirectories`,
+///             and `getUserDirectories` functions.  This will be removed
+///             in version 0.3.0.
+///
+deprecated("Use new get{Base,Project,User}Directories functions (remove 0.3.0)")
 public enum Directory
-  {
-   home,
-   data,
-   config,
-   state,
-   //   dataDirs,   /* XDG */
-   //   configDirs, /* XDG */
-   cache,
-   runtime,
-  }
+{
+    home,
+    data,
+    config,
+    state,
+    //   dataDirs,   /* XDG */
+    //   configDirs, /* XDG */
+    cache,
+    runtime,
+}
+
+///
+/// Provides paths of user-invisible standard directories, following the
+/// conventions of the operating system the library is running on.
+///
+/// To compute the location of cache, config or data directories for
+/// individual projects or applications, use ProjectDirectories instead.
+///
+/// ## Examples
+///
+/// All examples on this page are computed with a user named
+/// $(I Elq).
+///
+/// An example of `BaseDirectories#configDir`:
+///
+/// $(UL
+///   $(LI $(B Posix): `/home/elq/.config`)
+///   $(LI $(B macOS): $(RED Currently not supported))
+///   $(LI $(B Windows): `C:\Users\Elq\AppData\Roaming`)
+/// )
+///
+struct BaseDirectories
+{
+    ///
+    /// Returns the path to the user's home directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$HOME`)
+    ///     $(TD /home/elq)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD `FOLDERID_Profile`)
+    ///     $(TD C:\Users\Elq)
+    ///   )
+    /// )
+    ///
+    immutable string homeDir;
+
+    ///
+    /// Returns the path to the user's cache directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$XDG_CACHE_HOME` (fallback: `$HOME/.cache`))
+    ///     $(TD /home/elq/.cache)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD `FOLDERID_LocalAppData`)
+    ///     $(TD C:\Users\Elq\AppData\Local)
+    ///   )
+    /// )
+    ///
+    immutable string cacheDir;
+
+    ///
+    /// Returns the path to the user's configuration directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$XDG_CONFIG_HOME` (fallback: `$HOME/.config`))
+    ///     $(TD /home/elq/.config)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD `FOLDERID_RoamingAppData`)
+    ///     $(TD C:\Users\Elq\AppData\Roaming)
+    ///   )
+    /// )
+    ///
+    immutable string configDir;
+
+    ///
+    /// Returns the path to the user's data directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$XDG_DATA_HOME` (fallback: `$HOME/.local/share`))
+    ///     $(TD /home/elq/.local/share)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD `FOLDERID_RoamingAppData`)
+    ///     $(TD C:\Users\Elq\AppData\Roaming)
+    ///   )
+    /// )
+    ///
+    immutable string dataDir;
+
+    ///
+    /// Returns the path to the user's local data directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$XDG_DATA_HOME` (fallback: `$HOME/.local/share`))
+    ///     $(TD /home/elq/.local/share)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD `FOLDERID_LocalAppData`)
+    ///     $(TD C:\Users\Elq\AppData\Local)
+    ///   )
+    /// )
+    ///
+    immutable string dataLocalDir;
+
+    ///
+    /// Returns the path to the user's local executable directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$HOME/.local/bin`)
+    ///     $(TD /home/elq/.local/bin)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD N/A)
+    ///     $(TD `""`)
+    ///   )
+    /// )
+    ///
+    immutable string executableDir;
+
+    ///
+    /// Returns the path to the user's preference directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$XDG_CONFIG_HOME` (fallback: `$HOME/.config`))
+    ///     $(TD /home/elq/.config)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD `FOLDERID_RoamingAppData`)
+    ///     $(TD C:\Users\Elq\AppData\Roaming)
+    ///   )
+    /// )
+    ///
+    immutable string preferenceDir;
+
+    ///
+    /// Returns the path to the user's runtime directory.
+    ///
+    /// $(TABLE
+    ///   $(TR
+    ///     $(TH Platform)
+    ///     $(TH Value)
+    ///     $(TH Example)
+    ///   )
+    ///   $(TR
+    ///     $(TD Posix)
+    ///     $(TD `$XDG_RUNTIME_DIR`)
+    ///     $(TD /run/user/1000)
+    ///   )
+    ///   $(TR
+    ///     $(TD macOS)
+    ///     $(TD $(RED Platform not supported))
+    ///     $(TD $(RED Platform not supported))
+    ///   )
+    ///   $(TR
+    ///     $(TD Windows)
+    ///     $(TD N/A)
+    ///     $(TD `""`)
+    ///   )
+    /// )
+    ///
+    immutable string runtimeDir;
+
+    string toString() const @safe pure nothrow
+    {
+        version (OSX) {
+            enum platform = "OSX";
+        } else version (Posix) {
+            enum platform = "Posix";
+        } else version (Windows) {
+            enum platform = "Windows";
+        }
+
+        return "BaseDirectories(" ~ platform ~ "):\n" ~
+            "  homeDir       = '" ~ homeDir ~ "'\n" ~
+            "  cacheDir      = '" ~ cacheDir ~ "'\n" ~
+            "  configDir     = '" ~ configDir ~ "'\n" ~
+            "  dataDir       = '" ~ dataDir ~ "'\n" ~
+            "  dataLocalDir  = '" ~ dataLocalDir ~ "'\n" ~
+            "  executableDir = '" ~ executableDir ~ "'\n" ~
+            "  preferenceDir = '" ~ preferenceDir ~ "'\n" ~
+            "  runtimeDir    = '" ~ runtimeDir ~ "'\n";
+    }
+}
+
+///
+/// Returns a new instance of `BaseDirectories`.
+///
+/// The instance is an immutable snapshop of the state of the system at
+/// the time this function is called.  Subsequent changes to the state
+/// of the system are not reflected in instances created prior to such
+/// a change.
+///
+nothrow BaseDirectories getBaseDirectories()
+{
+    // OS X first so it doesn't get mixed with Posix.
+    version (OSX) {
+        // Support will be added.
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    } else version (Posix) {
+        return BaseDirectories(
+            posixHome(),
+            xdgCache(),
+            xdgConfig(),
+            xdgData(),
+            xdgData(),
+            // from spec:
+            //   User-specific executable files may be stored in $HOME/.local/bin.
+            buildPath(posixHome(), ".local", "bin"),
+            xdgConfig(),
+            xdgRuntime()
+        );
+    } else version (Windows) {
+        string dataDir = windowsRoamingData();
+        string localDataDir = windowsLocalData();
+
+        return BaseDirectories(
+            windowsHome(),
+            localDataDir,
+            dataDir,
+            dataDir,
+            localDataDir,
+            "",
+            dataDir,
+            ""
+        );
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
+}
+
+///
+unittest
+{
+    import std.stdio : writeln;
+
+    BaseDirectories baseDirs = getBaseDirectories();
+    writeln(baseDirs);
+}
+
+///
+/// `ProjectDirectories ` computes the location of cache, config, or
+/// data directories for a specific application, which are derived from
+/// the standard directories and the name of the project/organisation.
+///
+/// ## Examples
+///
+/// All examples in this section are computed with a user named *Elq*,
+/// and a `ProjectDirectories` instance created with the following
+/// information:
+///
+/// ```d
+/// ProjectDirectories projectDirs = getProjectDirectories("com", "Foo Corp", "Bar App");
+/// ```
+///
+/// Example of `ProjectDirectories#configDir` value in different
+/// operating systems:
+///
+/// $(UL
+///  $(LI $(B Posix): `/home/elq/.config/barapp`)
+///  $(LI $(B macOS): $(RED Platform not supported))
+///  $(LI $(B Windows): `C:\Users\Elq\AppData\Roaming\Foo Corp\Bar App\config`)
+/// )
+///
+struct ProjectDirectories
+{
+    ///
+    /// The path to the project's cache directory in which
+    /// `<project_path>` is the value of `ProjectDirectories#projectPath`.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_CACHE_HOME/<project_path>` (fallback: `$HOME/.cache/<project_path>`))
+    ///   $(TD /home/elq/.cache/barapp)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_LocalAppData\<project_path>\cache`)
+    ///   $(TD C:\Users\Elq\AppData\Local\Foo Corp\Bar App\cache )
+    ///   )
+    /// )
+    ///
+    immutable string cacheDir;
+
+    ///
+    /// The path to the project's configuration directory, in which
+    /// `<project_path>` is the value of `ProjectDirectories#projectPath`.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_CONFIG_HOME/<project_path>` (fallback: `$HOME/.config/<project_path>/`))
+    ///   $(TD /home/elq/.config/barapp)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_RoamingAppData\<project_path>\config`)
+    ///   $(TD C:\Users\Elq\AppData\Roaming\Foo Corp\Bar App\config )
+    ///   )
+    /// )
+    ///
+    immutable string configDir;
+
+    ///
+    /// The path to the project's data directory, in which
+    /// `<project_path>` is the value of `ProjectDirectories#projectPath`.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_DATA_HOME/<project_path>` (fallback: `$HOME/.local/share/<project_path>/`))
+    ///   $(TD /home/elq/.local/share/barapp)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_RoamingAppData\<project_path>\data`)
+    ///   $(TD C:\Users\Elq\AppData\Roaming\Foo Corp\Bar App\data )
+    ///   )
+    /// )
+    ///
+    immutable string dataDir;
+
+    ///
+    /// The path to the project's local data directory, in which
+    /// `<project_path>` is the value of `ProjectDirectories#projectPath`.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_DATA_HOME/<project_path>` (fallback: `$HOME/.local/share/<project_path>/`))
+    ///   $(TD /home/elq/.local/share/barapp)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_LocalAppData\<project_path>\data`)
+    ///   $(TD C:\Users\Elq\AppData\Local\Foo Corp\Bar App\data )
+    ///   )
+    /// )
+    ///
+    immutable string dataLocalDir;
+
+    ///
+    /// The path to the project's preference directory, in which
+    /// `<project_path>` is the value of `ProjectDirectories#projectPath`.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_CONFIG_HOME/<project_path>` (fallback: `$HOME/.config/<project_path>/`))
+    ///   $(TD /home/elq/.config/barapp)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_RoamingAppData\<project_path>\config`)
+    ///   $(TD C:\Users\Elq\AppData\Roaming\Foo Corp\Bar App\config)
+    ///   )
+    /// )
+    ///
+    immutable string preferenceDir;
+
+    ///
+    /// The path to the project's data directory, in which
+    /// `<project_path>` is the value of `ProjectDirectories#projectPath`.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_RUNTIME_DIR`)
+    ///   $(TD /run/user/1001/bareapp)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD N/A)
+    ///   $(TD `""`)
+    ///   )
+    /// )
+    ///
+    immutable string runtimeDir;
+
+    ///
+    /// The project path fragment used to compute the project's
+    /// cache/config/data directories.
+    ///
+    /// The value is derived from the arguments provided to the
+    /// `getProjectDirectories()` function and is platform-dependent.
+    ///
+    immutable string projectPath;
+
+    string toString() const @safe pure nothrow
+    {
+        version (OSX) {
+            enum platform = "OSX";
+        } else version (Posix) {
+            enum platform = "Posix";
+        } else version (Windows) {
+            enum platform = "Windows";
+        }
+
+        return "ProjectDirectories(" ~ platform ~ ")\n" ~
+            "  projectPath   = '" ~ projectPath ~ "'\n" ~
+            "  cacheDir      = '" ~ cacheDir ~ "'\n" ~
+            "  configDir     = '" ~ configDir ~ "'\n" ~
+            "  dataDir       = '" ~ dataDir ~ "'\n" ~
+            "  dataLocalDir  = '" ~ dataLocalDir ~ "'\n" ~
+            "  preferenceDir = '" ~ preferenceDir ~ "'\n" ~
+            "  runtimeDir    = '" ~ runtimeDir ~ "'\n";
+    }
+}
+
+///
+/// Return an instance of `ProjectDirectories` from values describing
+/// the project.
+///
+/// Params:
+///   qualifier =    The reverse domain name notation of the application,
+///                  excluding the organisation or application name itself. $(BR)
+///                  An example string can be passed if no qualifier should
+///                  be used (only affects macOS). $(BR)
+///                  Example values: `"com.example"`, `"org"`, `"co.uk"`, `""`.
+///
+///   organisation = The name of the organisation that develops this application,
+///                  or for which the application is developed.$(BR)
+///                  An empty string can be passed if no organisation should be
+///                  used (only affects macOS and Windows).$(BR)
+///                  Example values: `"Foo Corp"`, `"Alice and Bob Inc"`, `""`.
+///
+///   application =  The name of the application itself.$(BR)
+///                  Example values: `"Bar App"`, `"ExampleProgram"`, `"Unicorn-Programme"`.
+///
+/// Returns: An instance of `ProjectDirectories`, whose directory field values are
+///          based on the `qualifier`, `organisation`, and `application` arguments.
+///
+ProjectDirectories getProjectDirectories(string qualifier, string organisation, string application) nothrow
+in
+{
+    assert(!empty(organisation) && !empty(application),
+        "The organisation and the application arguments cannot both be empty");
+}
+do
+{
+    version (OSX)
+    {
+        // Support will be added.
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
+    else version (Posix)
+    {
+        import std.uni : isWhite, toLower;
+
+        // Yes, we could call toLower(replace(string(application), " ", "-"))
+        // but that could throw. This is nothrow.
+        string subPath;
+        bool reachedNonWhitespace = false;
+
+        foreach(c; application) {
+            if (' ' == c) {
+                // Check it's not a newline or something silly.
+                if (reachedNonWhitespace && false == isWhite(c)) {
+                    subPath ~= '-';
+                    // We only want one '-', so make sure
+                    // to skip any succeeding spaces.
+                    reachedNonWhitespace = false;
+                }
+            } else {
+                subPath ~= toLower(c);
+                reachedNonWhitespace = true;
+            }
+        }
+
+        string configDir = buildPath(xdgConfig(), subPath);
+        string dataDir = buildPath(xdgData(), subPath);
+
+        return ProjectDirectories(
+            buildPath(xdgCache(), subPath),
+            configDir,
+            dataDir,
+            dataDir,
+            configDir,
+            xdgRuntime(subPath),
+            subPath
+        );
+    }
+    else version (Windows)
+    {
+        bool hasOrg = !empty(organisation);
+        bool hasApp = !empty(application);
+        string subPath;
+        if (hasOrg)
+        {
+            subPath = organisation;
+            if (hasApp)
+            {
+                subPath ~= "\\";
+            }
+        }
+        if (hasApp)
+        {
+            subPath ~= application;
+        }
+
+        string roamingAppData = buildPath(GetKnownFolder(FOLDERID_RoamingAppData), subPath);
+        string localAppData = buildPath(GetKnownFolder(FOLDERID_LocalAppData), subPath);
+        string configDir = buildPath(roamingAppData, "config");
+
+        return ProjectDirectories(
+            buildPath(localAppData, "cache"),
+            configDir,
+            buildPath(roamingAppData, "data"),
+            buildPath(localAppData, "data"),
+            configDir,
+            "",
+            subPath
+        );
+    }
+    else
+    {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
+}
+
+///
+unittest
+{
+    import std.stdio : writeln;
+
+    ProjectDirectories projectDirs = getProjectDirectories("net", "Sporadic Programmers", "Foo bar-baz");
+    writeln(projectDirs);
+}
+
+///
+/// Provides the paths of user-facing standard directories, following
+/// the conventions of the operating system the library is running on.
+///
+/// ## Examples
+///
+/// All examples in this section are computed with a user named $(I Elq).
+///
+/// Example of `UserDirectories#audioDir` value in different operating systems:
+///
+/// $(UL
+///  $(LI $(B Posix): `/home/elq/Music`)
+///  $(LI $(B macOS): $(RED Platform not supported.))
+///  $(LI $(B Windows): `C:\Users\Elq\Music`)
+/// )
+///
+struct UserDirectories
+{
+    ///
+    /// The path to the user's home directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$HOME`)
+    ///   $(TD /home/elq)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Profile`)
+    ///   $(TD C:\Users\Elq)
+    ///   )
+    /// )
+    ///
+    immutable string homeDir;
+
+    ///
+    /// The path to the user's audio directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_MUSIC_DIR`)
+    ///   $(TD /home/elq/Music)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Music`)
+    ///   $(TD C:\Users\Elq\Music)
+    ///   )
+    /// )
+    ///
+    immutable string audioDir;
+
+    ///
+    /// The path to the user's desktop directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_DESKTOP_DIR`)
+    ///   $(TD /home/elq/Desktop)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Desktop`)
+    ///   $(TD C:\Users\Elq\Desktop)
+    ///   )
+    /// )
+    ///
+    immutable string desktopDir;
+
+    ///
+    /// The path to the user's documents directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_DOCUMENTS_DIR`)
+    ///   $(TD /home/elq/Documents)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Documents`)
+    ///   $(TD C:\Users\Elq\Documents)
+    ///   )
+    /// )
+    ///
+    immutable string documentDir;
+
+    ///
+    /// The path to the user's download directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_DOWNLOAD_DIR`)
+    ///   $(TD /home/elq/Downloads)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Downloads`)
+    ///   $(TD C:\Users\Elq\Downloads)
+    ///   )
+    /// )
+    ///
+    immutable string downloadDir;
+
+    ///
+    /// The path to the user's fonts directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_DATA_HOME/fonts` (fallback: `$HOME/.local/share/fonts`))
+    ///   $(TD /home/elq/.local/share/fonts)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD N/A)
+    ///   $(TD `""`)
+    ///   )
+    /// )
+    ///
+    immutable string fontDir;
+
+    ///
+    /// The path to the user's pictures directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_PICTURES_DIR`)
+    ///   $(TD /home/elq/Pictures)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Pictures`)
+    ///   $(TD C:\Users\Elq\Pictures)
+    ///   )
+    /// )
+    ///
+    immutable string pictureDir;
+
+    ///
+    /// The path to the user's public directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_PUBLICSHARE_DIR`)
+    ///   $(TD /home/elq/Public)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Public`)
+    ///   $(TD C:\Users\Public)
+    ///   )
+    /// )
+    ///
+    immutable string publicDir;
+
+    ///
+    /// The path to the user's template directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_TEMPLATES_DIR`)
+    ///   $(TD /home/elq/Templates)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Templates`)
+    ///   $(TD C:\Users\Elq\AppData\Roaming\Microsoft\Windows\Templates)
+    ///   )
+    /// )
+    ///
+    immutable string templateDir;
+
+    ///
+    /// The path to the user's video directory.
+    ///
+    /// $(TABLE
+    ///  $(TR
+    ///   $(TH Platform)
+    ///   $(TH Value)
+    ///   $(TH Example)
+    ///   )
+    ///  $(TR
+    ///   $(TD Posix)
+    ///   $(TD `$XDG_VIDEOS_DIR`)
+    ///   $(TD /home/elq/Videos)
+    ///   )
+    ///  $(TR
+    ///   $(TD macOS)
+    ///   $(TD $(RED Platform not supported))
+    ///   $(TD $(RED Platform not supported))
+    ///   )
+    ///  $(TR
+    ///   $(TD Windows)
+    ///   $(TD `FOLDERID_Videos`)
+    ///   $(TD C:\Users\Elq\Videos)
+    ///   )
+    /// )
+    ///
+    immutable string videoDir;
+
+    string toString() const @safe pure nothrow
+    {
+        version (OSX)
+        {
+            enum platform = "OSX";
+        }
+        else version (Posix)
+        {
+            enum platform = "Posix";
+        }
+        else version (Windows)
+        {
+            enum platform = "Windows";
+        }
+        return "UserDirectories(" ~ platform ~ ")\n" ~
+            "  homeDir     = '" ~ homeDir ~ "'\n" ~
+            "  audioDir    = '" ~ audioDir ~ "'\n" ~
+            "  desktopDir  = '" ~ desktopDir ~ "'\n" ~
+            "  documentDir = '" ~ documentDir ~ "'\n" ~
+            "  downloadDir = '" ~ downloadDir ~ "'\n" ~
+            "  fontDir     = '" ~ fontDir ~ "'\n" ~
+            "  pictureDir  = '" ~ pictureDir ~ "'\n" ~
+            "  publicDir   = '" ~ publicDir ~ "'\n" ~
+            "  templateDir = '" ~ templateDir ~ "'\n" ~
+            "  videoDir    = '" ~ videoDir ~ "'\n";
+    }
+}
+
+///
+/// Get a new instance of `UserDirectories`.
+///
+/// The instance is an immutable snapshop of the current state of the
+/// system at the time this function was called.  Subsequent changes
+/// to the state of the system are not reflected in instances created
+/// prior to such a change.
+///
+nothrow UserDirectories getUserDirectories()
+{
+    version (OSX) {
+        // Support will be added.
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    } else version (Posix) {
+        // Fallbacks are from on
+        // https://cgit.freedesktop.org/xdg/xdg-user-dirs/tree/user-dirs.defaults
+        return UserDirectories(
+            posixHome(),
+            xdgDir("MUSIC", buildPath(posixHome(), "Music")),
+            xdgDir("DESKTOP", buildPath(posixHome(), "Desktop")),
+            xdgDir("DOCUMENTS", buildPath(posixHome(), "Documents")),
+            xdgDir("DOWNLOAD", buildPath(posixHome(), "Downloads")),
+            buildPath(xdgData(), "fonts"),
+            xdgDir("PICTURES", buildPath(posixHome(), "Pictures")),
+            xdgDir("PUBLICSHARE", buildPath(posixHome(), "Public")),
+            xdgDir("TEMPLATES", buildPath(posixHome(), "Templates")),
+            xdgDir("VIDEOS", buildPath(posixHome(), "Videos"))
+        );
+    } else version (Windows) {
+        return UserDirectories(
+            windowsHome(),
+            GetKnownFolder(FOLDERID_Music),
+            GetKnownFolder(FOLDERID_Desktop),
+            GetKnownFolder(FOLDERID_Documents),
+            GetKnownFolder(FOLDERID_Downloads),
+            "",
+            GetKnownFolder(FOLDERID_Pictures),
+            GetKnownFolder(FOLDERID_Public),
+            GetKnownFolder(FOLDERID_Templates),
+            GetKnownFolder(FOLDERID_Videos)
+        );
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
+}
+
+///
+unittest
+{
+    import std.stdio : writeln;
+    UserDirectories userDirs = getUserDirectories();
+    writeln(userDirs);
+}
 
 /++
  Return a DirEntry pointing to `dt`.
- 
+
  If the folder couldn't be found, an empty DirEntry is returned.
- 
+
+ Deprecated: Use the new `getBaseDirectories`, `getProjectDirectories`,
+             and `getUserDirectories` functions.  This will be removed
+             in version 0.3.0.
+
  Examples:
  ----
  import directories;
@@ -92,72 +1166,55 @@ public enum Directory
  }
  ----
 +/
+deprecated("Use new get{Base,Project,User}Directories functions (remove 0.3.0)")
 public DirEntry open(Directory dt) nothrow// @safe
 {
-  /* 
-   * Posix covers a few operating systems, if yours has a alternate
-   * structure that is preferred over XDG, let me know.
-   */
-  version (Posix) enum supported = true;
-  else enum supported = false;
-  /* More operating systems will be supported soon-ish. */
-
-  static if (false == supported)
-    {
-      import core.stdc.stdio : fprintf, stderr;
+    /*
+     * The Posix version covers a few operating systems, if your uses an
+     * an alternative to XDG, let me know.
+     */
+    version (Posix) enum supported = true;
+    else version (Windows) enum supported = true;
+    else enum supported = false;
 
-      fprintf(stderr, "*** error: The operating system you're running isn't supported. ***\n");
-      // TODO: webpage for general contribution guide reporting.
-      assert(false, "Unsupported platform.");
+    static if (false == supported) {
+        static assert(0, "Unsupported platform.");
     }
 
-  immutable string path = getPath(dt);
-  if (path is null) return DirEntry();
-  try {
-    return DirEntry(path);
-  } catch (Exception e) {
-    return DirEntry();
-  }
+    immutable string path = getPath(dt);
+    if (path is null) return DirEntry();
+    try {
+        return DirEntry(path);
+    } catch (Exception e) {
+        return DirEntry();
+    }
 }
 
 ///
 unittest
 {
-  import std.process : environment;
-  import std.path : buildPath;
-
-  /*
-   * Environment Variables (for checking against)
-   * Currently only tests on Posix since that's the only supported
-   * platform.
-   */
-  immutable string homeE = environment.get("HOME");
-  immutable string configE = environment.get("XDG_CONFIG_HOME",
-					     buildPath(homeE, ".config"));
-  immutable string dataE = environment.get("XDG_DATA_HOME",
-					   buildPath(homeE, ".local", "share"));
-  immutable string cacheE = environment.get("XDG_CACHE_HOME",
-					    buildPath(homeE, ".cache"));
-
-  // Compare against folders.d (note that folders is cross-platform, so
-  // some errors may occur on non-POSIX)
-  assert(homeE == open(Directory.home));
-  assert(configE == open(Directory.config));
-  assert(dataE == open(Directory.data));
-  assert(cacheE == open(Directory.cache));
-}
+    import std.conv : to;
+    import std.stdio : stderr;
 
-private:
+    DirEntry emptyDir;
 
-void errLog(string msg) nothrow @trusted
-{
-  import core.stdc.stdio : fprintf, stderr;
-  
-  // TODO: webpage for general issue reporting.
-  // fprintf(stderr, "**  info: report bugs to https://yume-neru.neocities.org/bugs.html **\n");
-  fprintf(stderr, "*** error: %s ***\n", msg.ptr);
+    foreach(dir; Directory.min..Directory.max)
+    {
+        string dirAsString = to!string(dir);
+        DirEntry dirEntry = open(dir);
+        version (Windows)
+        {
+            // Neither of these directories are supported on Windows.
+            if (dir == Directory.state || dir == Directory.runtime)
+                continue;
+        }
+        assert(emptyDir != dirEntry, "Failed to open(Directory." ~ dirAsString ~ ")");
+        stderr.writefln("Successfully opened Directory.%s: %s", dirAsString, dirEntry.name());
+    }
 }
 
+private:
+
 immutable(string) getPath(in Directory dt) nothrow @safe
 {
   switch (dt)
@@ -181,104 +1238,77 @@ immutable(string) getPath(in Directory dt) nothrow @safe
 
 immutable(string) home() nothrow @trusted
 {
-  import std.path : isAbsolute;
-  import std.process : environment;
-    
-  string homeE;
-    
-  try {
-    homeE = environment.get("HOME");
-  } catch (Exception e) {
-    homeE = null;
-  }
-    
-  if (homeE is null) {
-    import std.string : fromStringz;
-    const(char)* pwdHome = fallbackHome();
-    if (pwdHome !is null)
-      homeE = cast(string)(pwdHome.fromStringz).dup;
-    if (false == homeE.isAbsolute)
-      homeE = null;
-  }
-  return homeE;
+    version (Posix) {
+        return posixHome();
+    } else version (Windows) {
+        return windowsHome();
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
 }
 
 immutable(string) data() nothrow @safe
 {
-  import std.path : buildPath, isAbsolute;
-  import std.process : environment;
-
-  string dataE;
-
-  try {
-    dataE = environment.get("XDG_DATA_HOME");
-  } catch (Exception e) {
-    dataE = null;
-  }
-
-  if (dataE is null || false == dataE.isAbsolute)
-    dataE = buildPath(home(), ".local", "share");
-
-  return dataE;
+    version (Posix) {
+        return xdgData();
+    } else version (Windows) {
+        return windowsRoamingData();
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
 }
 
 immutable(string) config() nothrow @safe
 {
-  import std.path : buildPath, isAbsolute;
-  import std.process : environment;
-    
-  string configE;
-    
-  try {
-    configE = environment.get("XDG_CONFIG_HOME");
-  } catch (Exception e) {
-    configE = null;
-  }
-    
-  if (configE is null || false == configE.isAbsolute)
-    configE = buildPath(home(), ".config");
-
-  return configE;
+    version (Posix) {
+        return xdgConfig();
+    } else version (Windows) {
+        return GetKnownFolder(FOLDERID_RoamingAppData);
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
 }
 
 /* TODO: xdgState() nothrow @safe */
 
 immutable(string) cache() nothrow @safe
 {
-  import std.path : buildPath, isAbsolute;
-  import std.process : environment;
-
-  string cacheE;
-
-  try {
-    cacheE = environment.get("XDG_CACHE_HOME");
-  } catch (Exception e) {
-    cacheE = null;
-  }
-
-  if (cacheE is null || false == cacheE.isAbsolute)
-    cacheE = buildPath(home(), ".cache");
-
-  return cacheE;
+    version (Posix) {
+        return xdgCache();
+    } else version (Windows) {
+        return GetKnownFolder(FOLDERID_LocalAppData);
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
 }
 
 immutable(string) state() nothrow @safe
 {
-  import std.path : buildPath, isAbsolute;
-  import std.process : environment;
+    version (Windows)
+    {
+        return "";
+    }
+    else
+    {
+        import std.path : buildPath, isAbsolute;
+        import std.process : environment;
 
-  string stateEnvValue;
+        string stateEnvValue;
 
-  try {
-    stateEnvValue = environment.get("XDG_STATE_HOME");
-  } catch (Exception e) {
-    stateEnvValue = null;
-  }
+        try
+        {
+            stateEnvValue = environment.get("XDG_STATE_HOME");
+        }
+        catch (Exception e)
+        {
+            stateEnvValue = null;
+        }
 
-  if (stateEnvValue is null || false == stateEnvValue.isAbsolute)
-    stateEnvValue = buildPath(home(), ".local", "state");
+        if (stateEnvValue is null || false == stateEnvValue.isAbsolute)
+            stateEnvValue = buildPath(home(), ".local", "state");
 
-  return stateEnvValue;
+        return stateEnvValue;
+    }
 }
 
 ///
@@ -292,70 +1322,369 @@ immutable(string) state() nothrow @safe
 ///
 immutable(string) runtime() nothrow @safe
 {
-  import std.process : environment;
-
-  try {
-    return environment.get("XDG_RUNTIME_DIR");
-  } catch (Exception e) {
-    return null;
-  }
+    version (Posix) {
+        return xdgRuntime("");
+    } else version (Windows) {
+        return "";
+    } else {
+        static assert(false, "mlib.directories: Unsupported operating system.");
+    }
 }
 
-/* Helpers */
-
-const(char)* fallbackHome() nothrow @trusted
+version (Posix)
 {
-    import core.stdc.string : strdup;
+    import std.path : buildPath, isAbsolute;
+    import std.process : environment;
+    import std.string : empty;
 
-    passwd* pw;
-    char* home;
+    immutable(string) posixHome() nothrow
+    {
+        string homeE;
 
-    setpwent();
-    pw = getpwuid(getuid());
-    endpwent();
+        try
+        {
+            homeE = environment.get("HOME");
+        }
+        catch (Exception e)
+        {
+            homeE = null;
+        }
 
-    if (pw is null || pw.pw_dir is null)
-        return null;
+        if (homeE is null)
+        {
+            import std.string : fromStringz;
 
-    home = strdup(pw.pw_dir);
-    return home;
-}
+            const(char)* pwdHome = _posix_fallback_home();
+            if (pwdHome !is null)
+                homeE = cast(string)(pwdHome.fromStringz).dup;
+            if (false == homeE.isAbsolute)
+                homeE = null;
+        }
+        return homeE;
+    }
 
-@system @nogc extern(C) nothrow
-{
-    /* <bits/types.h> */
-    alias gid_t = uint;
-    alias uid_t = uint;
-    
-    /* <pwd.h> */
-    struct passwd
+    ///
+    /// Retrieve the XDG User Directory for the specified $(I dirName).
+    ///
+    /// This will attempt to read the XDG_$(I dirName)_DIR environment
+    /// variable.  If it is not found, then we attempt to call the
+    /// xdg-user-dir program.  Should this not be installed, then
+    /// the result of $(I fallback) (if provided) is returned or the
+    /// empty string.
+    ///
+    /// Please note: If xdg-user-dir is installed, then $(I fallback)
+    /// will never be called. xdg-user-dir always succeeds and will
+    /// return the user's home directory if $(I dirName) isn't a valid
+    /// value.
+    ///
+    /// Params:
+    ///   dirName = The XDG Directory name.
+    ///   fallback = The fallback to use if the environment variable
+    ///              is not set and xdg-user-dir is not installed.
+    ///
+    ///
+    nothrow string xdgDir(string dirName, lazy string fallback = null) {
+        import std.process : execute;
+        import std.string : strip;
+
+        string varValue;
+
+        try {
+            varValue = environment.get("XDG_" ~ dirName ~ "_DIR");
+        } catch (Exception) {
+            varValue = "";
+        }
+
+        try {
+            if (empty(varValue)) {
+                auto xdgRes = execute(["xdg-user-dir", dirName]);
+                if (xdgRes.status == 0) {
+                    return strip(xdgRes.output);
+                }
+            }
+        } catch (Exception) {
+            varValue = "";
+        }
+
+        try {
+            if (null !is fallback) {
+                varValue = fallback();
+            }
+        } catch (Exception) {
+            varValue = "";
+        }
+
+        return varValue;
+    }
+
+    string xdgCache() nothrow @safe
     {
-        /// Username
-        char* pw_name;
-        /// Hashed passphrase, if shadow database is not in use
-        char* pw_password;
-        /// User ID
-        uid_t pw_uid;
-        /// Group ID
-        gid_t pw_gid;
-        /// "Real" name
-        char* pw_gecos;
-        /// Home directory
-        char* pw_dir;
-        /// Shell program
-        char* pw_shell;
-    }
-    
-    /// Rewind the user database stream
-    extern void setpwent();
-    
-    /// Close the user database stream
-    extern void endpwent();
-    
-    /// Retrieve the user database entry for the given user ID
-    extern passwd* getpwuid(uid_t uid);
-    
-    /* <unistd.h> */
-    /// Returns the real user ID of the calling process.
-    extern uid_t getuid();
-}
+        string cacheDir;
+
+        try {
+            cacheDir = environment.get("XDG_CACHE_HOME");
+        } catch (Exception) {
+            cacheDir = "";
+        }
+
+        if (empty(cacheDir) || !isAbsolute(cacheDir)) {
+            cacheDir = buildPath(home(), ".cache");
+        }
+
+        return cacheDir;
+    }
+
+    string xdgConfig() nothrow @safe
+    {
+        string configDir;
+
+        try {
+            configDir = environment.get("XDG_CONFIG_HOME");
+        } catch (Exception) {
+            configDir = "";
+        }
+
+        if (empty(configDir) || !isAbsolute(configDir))
+            configDir = buildPath(home(), ".config");
+
+        return configDir;
+    }
+
+    string xdgData() nothrow @safe
+    {
+        import std.path : buildPath, isAbsolute;
+        import std.process : environment;
+
+        string dataE;
+
+        try
+        {
+            dataE = environment.get("XDG_DATA_HOME");
+        }
+        catch (Exception e)
+        {
+            dataE = null;
+        }
+
+        if (dataE is null || false == dataE.isAbsolute)
+            dataE = buildPath(home(), ".local", "share");
+
+        return dataE;
+    }
+
+    string xdgRuntime(string subPath = null) nothrow @safe
+    {
+        string runtimeDir;
+
+        try {
+            runtimeDir = environment.get("XDG_RUNTIME_DIR");
+        } catch (Exception e) {
+            return "";
+        }
+
+        if (subPath !is null) {
+            runtimeDir = buildPath(runtimeDir, subPath);
+        }
+
+        return runtimeDir;
+    }
+
+    /* Unit tests */
+    unittest
+    {
+        import std.process : environment;
+        import std.path : buildPath;
+
+        /*
+         * Environment Variables (for checking against)
+         */
+        immutable string homeE = environment.get("HOME");
+        immutable string configE = environment.get("XDG_CONFIG_HOME",
+            buildPath(homeE, ".config"));
+        immutable string dataE = environment.get("XDG_DATA_HOME",
+            buildPath(homeE, ".local", "share"));
+        immutable string cacheE = environment.get("XDG_CACHE_HOME",
+            buildPath(homeE, ".cache"));
+
+        // Compare against directories.d
+        assert(homeE == open(Directory.home));
+        assert(configE == open(Directory.config));
+        assert(dataE == open(Directory.data));
+        assert(cacheE == open(Directory.cache));
+    }
+
+    /* Helpers */
+    const(char)* _posix_fallback_home() nothrow @trusted
+    {
+        import core.stdc.string : strdup;
+
+        passwd* pw;
+        char* home;
+
+        setpwent();
+        pw = getpwuid(getuid());
+        endpwent();
+
+        if (pw is null || pw.pw_dir is null)
+            return null;
+
+        home = strdup(pw.pw_dir);
+        return home;
+    }
+
+    @system @nogc extern (C) nothrow
+    {
+        /* <bits/types.h> */
+        alias gid_t = uint;
+        alias uid_t = uint;
+
+        /* <pwd.h> */
+        struct passwd
+        {
+            /// Username
+            char* pw_name;
+            /// Hashed passphrase, if shadow database is not in use
+            char* pw_password;
+            /// User ID
+            uid_t pw_uid;
+            /// Group ID
+            gid_t pw_gid;
+            /// "Real" name
+            char* pw_gecos;
+            /// Home directory
+            char* pw_dir;
+            /// Shell program
+            char* pw_shell;
+        }
+
+        /// Rewind the user database stream
+        extern void setpwent();
+
+        /// Close the user database stream
+        extern void endpwent();
+
+        /// Retrieve the user database entry for the given user ID
+        extern passwd* getpwuid(uid_t uid);
+
+        /* <unistd.h> */
+        /// Returns the real user ID of the calling process.
+        extern uid_t getuid();
+    }
+} // end of version (Posix)
+
+version (Windows) {
+    import std.path : buildPath;
+    import std.process : environment;
+    import std.string : empty;
+
+    pragma(lib, "ole32");
+
+    string windowsHome() nothrow {
+        string home;
+
+        try {
+            home = environment["USERPROFILE"];
+        } catch (Exception) {
+            home = "";
+        }
+
+        if (false == empty(home)) {
+            return home;
+        }
+
+        try {
+            scope homeDrive = environment["HOMEDRIVE"];
+            scope homePath = environment["HOMEPATH"];
+            home = homeDrive ~ homePath;
+        } catch (Exception) {
+            home = "";
+        }
+
+        if (false == empty(home)) {
+            return home;
+        }
+
+        return GetKnownFolder(FOLDERID_Profile);
+    }
+
+    string windowsRoamingData() nothrow @trusted
+    {
+        return GetKnownFolder(FOLDERID_RoamingAppData);
+    }
+
+    string windowsLocalData() nothrow @trusted
+    {
+        return GetKnownFolder(FOLDERID_LocalAppData);
+    }
+
+    /* Helpers */
+    import core.sys.windows.basetyps;
+    import core.sys.windows.objbase;
+    import core.sys.windows.windef;
+    import core.sys.windows.winnls;
+
+    alias KNOWNFOLDERID = GUID;
+    alias REFKNOWNFOLDERID = KNOWNFOLDERID*;
+
+    extern(C) nothrow @nogc @system
+    HRESULT SHGetKnownFolderPath(REFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
+
+    // {B4BFCC3A-DB2C-424C-B029-7FE99A87C641}
+    GUID FOLDERID_Desktop = GUID(0xB4BFCC3A, 0xDB2C, 0x424C, [0xB0, 0x29, 0x7F, 0xE9, 0x9A, 0x87, 0xC6, 0x41]);
+
+    // {FDD39AD0-238F-46AF-ADB4-6C85480369C7}
+    GUID FOLDERID_Documents = GUID(0xFDD39AD0, 0x238F, 0x46AF, [0xAD, 0xB4, 0x6C, 0x85, 0x48, 0x03, 0x69, 0xC7]);
+
+    // {A63293E8-664E-48DB-A079-DF759E0509F7}
+    GUID FOLDERID_Templates = GUID(0xA63293E8, 0x664E, 0x48DB, [0xA0, 0x79, 0xDF, 0x75, 0x9E, 0x05, 0x09, 0xF7]);
+
+    // {3EB685DB-65F9-4CF6-A03A-E3EF65729F3D}
+    GUID FOLDERID_RoamingAppData = GUID(0x3EB685DB, 0x65F9, 0x4CF6, [0xA0, 0x3A, 0xE3, 0xEF, 0x65, 0x72, 0x9F, 0x3D]);
+
+    // {F1B32785-6FBA-4FCF-9D55-7B8E7F157091}
+    GUID FOLDERID_LocalAppData = GUID(0xF1B32785, 0x6FBA, 0x4FCF, [0x9D, 0x55, 0x7B, 0x8E, 0x7F, 0x15, 0x70, 0x91]);
+
+    // {5E6C858F-0E22-4760-9AFE-EA3317B67173}
+    GUID FOLDERID_Profile = GUID(0x5E6C858F, 0x0E22, 0x4760, [0x9A, 0xFE, 0xEA, 0x33, 0x17, 0xB6, 0x71, 0x73]);
+
+    // {33E28130-4E1E-4676-835A-98395C3BC3BB}
+    GUID FOLDERID_Pictures = GUID(0x33E28130, 0x4E1E, 0x4676, [0x83, 0x5A, 0x98, 0x39, 0x5C, 0x3B, 0xC3, 0xBB]);
+
+    // {4BD8D571-6D19-48D3-BE97-422220080E43}
+    GUID FOLDERID_Music = GUID(0x4BD8D571, 0x6D19, 0x48D3, [0xBE, 0x97, 0x42, 0x22, 0x20, 0x08, 0x0E, 0x43]);
+
+    // {18989B1D-99B5-455B-841C-AB7C74E4DDFC}
+    GUID FOLDERID_Videos = GUID(0x18989B1D, 0x99B5, 0x455B, [0x84, 0x1C, 0xAB, 0x7C, 0x74, 0xE4, 0xDD, 0xFC]);
+
+    // {DFDF76A2-C82A-4D63-906A-5644AC457385}
+    GUID FOLDERID_Public = GUID(0xDFDF76A2, 0xC82A, 0x4D63, [0x90, 0x6A, 0x56, 0x44, 0xAC, 0x45, 0x73, 0x85]);
+
+    // {374DE290-123F-4565-9164-39C4925E467B}
+    GUID FOLDERID_Downloads = GUID(0x374de290, 0x123f, 0x4565, [0x91, 0x64, 0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b]);
+
+    string GetKnownFolder(KNOWNFOLDERID rdif) nothrow @trusted
+    {
+        PWSTR path;
+        HRESULT status;
+        ULONG bufferSize = 0;
+
+        status = SHGetKnownFolderPath(&rdif, 0, null, &path);
+        if (status != S_OK) {
+            CoTaskMemFree(path);
+            return "";
+        }
+        scope(exit) CoTaskMemFree(path);
+
+        UnicodeToAnsiSize(path, bufferSize);
+        // -1 to remove the null character which D doesn't use
+        char[] str = new char[bufferSize - 1];
+        WideCharToMultiByte(CP_UTF8, 0, path, -1, str.ptr, bufferSize - 1, null, null);
+
+        return cast(string)str;
+    }
+
+    void UnicodeToAnsiSize(in PWCHAR UnicodeString, out ULONG AnsiSizeInBytes) nothrow
+    {
+        AnsiSizeInBytes = WideCharToMultiByte(CP_UTF8, 0, UnicodeString, -1, null, 0, null, null);
+    }
+} // end of version (Windows)

--- /dev/null
+++ b/mlib/source/mlib/package.d
@@ -0,0 +1,7 @@
+///
+/// A collection of public domain modules for the
+/// $(LINK2 https://dlang.org, D Programming Language).
+///
+/// All modules are compatible with D versions 2.076.0 and newer.
+///
+module mlib;

--- a/mlib/source/mlib/trash.d
+++ b/mlib/source/mlib/trash.d
@@ -14,16 +14,18 @@
 /**
  * Common 'Trash' operations for the OS's Recycle Bin.
  *
- * Currently only for POSIX system. It follows the XDG specification.
+ * Supports POSIX (XDG Specification) and Windows. Proper support for
+ * macOS will be implemented in a future version.
  *
  * Authors: nemophila
  * Date: January 29, 2023
  * Homepage: https://osdn.net/users/nemophila/pf/mlib
  * License: 0BSD
  * Standards: The FreeDesktop.org Trash Specification 1.0
- * Version: 0.1.0
+ * Version: 0.2.0
  *
  * History:
+ *      0.2.0 added support for Windows
  *      0.1.0 is the initial version
  *
  * Macros:
@@ -94,6 +96,20 @@ void trash(string path)
     trash(path, pathInTrash);
 }
 
+///
+unittest
+{
+    import std.stdio : File;
+    import std.exception : assertNotThrown;
+
+    // Create a file with some basic text
+    auto file = File("hello.txt", "w+");
+    file.writeln("hello, world!");
+    file.close();
+
+    assertNotThrown!Exception(trash("hello.txt"));
+}
+
 /**
  * Trash the file or directory at *path*, and sets *pathInTrash* to the
  * path at which the file can be found within the trash.
@@ -102,6 +118,8 @@ void trash(string path)
  *  path = The path to move to the trash.
  *  pathInTrash = The path at which the newly trashed item can be found.
  *
+ * Bugs: The *pathInTrash* parameter isn't supported on Windows.
+ *
  * Throws:
  *  - $(DREF std_file, FileException) if the file cannot be trashed.
  */
@@ -109,6 +127,8 @@ void trash(string path, out string pathInTrash)
 {
     version (Posix) {
         _posix_trash(path, pathInTrash);
+    } else version (Windows) {
+        _windows_trash(path);
     } else {
         throw new Exception(__PRETTY_FUNCTION__ ~ " is not supported on your OS");
     }
@@ -141,12 +161,18 @@ private:
 ulong getDevice(string path) {
     version (Posix) {
         return _posix_getDevice(path);
+    } else {
+      // Not used on Windows
+      return 0;
     }
 }
 
 string getHomeDirectory() {
     version (Posix) {
         return environment["HOME"];
+    } else {
+      // Not used on Windows
+      return "";
     }
 }
 
@@ -304,3 +330,46 @@ version(Posix) {
         }
     }
 } // End of version(Posix)
+
+/*
+ * Disclaimer:
+ *
+ * I don't use Windows. As such, this may not be the _best_ way
+ * to send a file to the recycle bin. In theory it shouldn't
+ * break (given Windows' tendency for backwards support), but
+ * if there is an error, you'll either have to let me know
+ * or send a patch yourself.
+ */
+version(Windows) {
+    import core.sys.windows.windows;
+
+    import std.utf : toUTF16z;
+
+    // There doesn't seem to be a way to determine the path of a
+    // file in the Recycle Bin.
+    void _windows_trash(string path) {
+        // If the path is not absolute, then it won't be recycled.
+        string absPath = absolutePath(path);
+
+        SHFILEOPSTRUCT fileOp = SHFILEOPSTRUCTW(null, FO_DELETE);
+
+        /*
+         * NOTE:
+         * While toUTF16z appends a null character to the input string,
+         * SHFILEOPSTRUCT treats pFrom (and pTo) as a list of strings
+         * separated by a single '\0'.  To specify the end of the list,
+         * the string must end with double null terminator.
+         *
+         * See: https://learn.microsoft.com/en-us/windows/win32/api/shellapi/ns-shellapi-shfileopstructa#remarks
+         */
+        fileOp.pFrom = toUTF16z(absPath ~ '\0');
+        fileOp.pTo = null;
+        fileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;
+        fileOp.fAnyOperationsAborted = FALSE;
+        fileOp.lpszProgressTitle = null;
+
+        if (0 != SHFileOperation(&fileOp)) {
+            throw new FileException(path, "File could not be deleted");
+        }
+    }
+} // End of version(Windows)

--- a/update_deps.sh
+++ b/update_deps.sh
@@ -6,34 +6,25 @@
 FALSE=0
 TRUE=1
 
-_HAVE_GIT=$FALSE
 _HAVE_WGET=$FALSE
 _HAVE_CURL=$FALSE
 
-which git2  >/dev/null && _HAVE_GIT=$TRUE
 which wget >/dev/null && _HAVE_WGET=$TRUE
 which curl >/dev/null && _HAVE_CURL=$TRUE
 
-_DUB_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/trunk/dub.sdl?export=raw"
-_CNI_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/trunk/source/mlib/cni.d?export=raw"
-_DIR_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/trunk/source/mlib/directories.d?export=raw"
-_TSH_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/trunk/source/mlib/trash.d?export=raw"
+# Using separate values since there could be bugs with
+# a specific version.
+_DUB_COMMIT="8f1f7e3c05abc2734020727892988051ce25f29e"
+_CNI_COMMIT="8f1f7e3c05abc2734020727892988051ce25f29e"
+_DIR_COMMIT="8f1f7e3c05abc2734020727892988051ce25f29e"
+_TSH_COMMIT="8f1f7e3c05abc2734020727892988051ce25f29e"
 
+_DUB_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/$_DUB_COMMIT/dub.sdl?export=raw"
+_CNI_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/$_CNI_COMMIT/source/mlib/cni.d?export=raw"
+_DIR_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/$_DIR_COMMIT/source/mlib/directories.d?export=raw"
+_TSH_RAW_URL="https://osdn.net/users/nemophila/pf/mlib/scm/blobs/$_TSH_COMMIT/source/mlib/trash.d?export=raw"
 
-if [ $TRUE -eq $_HAVE_GIT ]
-then
-    # Update using GIT
-    if [ ! -d "mlib" ]
-    then
-	git clone git://git.pf.osdn.net/gitroot/n/ne/nemophila/mlib.git
-	cd mlib
-    else
-	cd mlib
-	git fetch && git pull --rebase
-    fi
-    _latest_tag="$(git tag --list v* | sort -r | head -n1)"
-    git checkout "$_latest_tag"
-elif [ $TRUE -eq $_HAVE_WGET ]
+if [ $TRUE -eq $_HAVE_WGET ]
 then
     # Update by fetching archive with wget
     [ ! -d mlib/source/mlib ] && mkdir -p mlib/source/mlib
@@ -46,6 +37,11 @@ then
 elif [ $TRUE -eq $_HAVE_CURL ]
 then
     # Update by fetching archive with curl
-    echo 's'
+    [ ! -d mlib/source/mlib ] && mkdir -p mlib/source/mlib
+    cd mlib
+    curl -o "dub.sdl" "$_DUB_RAW_URL" && sleep 2
+    cd source/mlib
+    curl -o "cni.d" "$_CNI_RAW_URL" && sleep 2
+    curl -o "directories.d" "$_DIR_RAW_URL" && sleep 2
+    curl -o "trash.d" "$_TSH_RAW_URL"
 fi
-