提交: a74177c5e751f0c002664d261acf4574ed72bc36 - mlib (git)

A D package containing my single-file modules

Commit MetaInfo

• 修訂: a74177c5e751f0c002664d261acf4574ed72bc36 (tree)
• 時間: 2023-11-02 10:08:25
• 作者: nemophila <stigma+osdn@disr...>
• Commiter: nemophila

Log Message

configparser: reformat and add attributes

Change Summary

• add: .editorconfig
• modified: source/mlib/configparser.d

差異

--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,6 @@
+[*.d]
+indent_style = space
+indent_size = 3
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true

--- a/source/mlib/configparser.d
+++ b/source/mlib/configparser.d
@@ -52,19 +52,19 @@ import std.range.primitives : isOutputRange;
 
 public class DuplicateSectionException : Exception
 {
-    private string m_section;
+   private string m_section;
 
-    this(string section) @safe pure
-    {
-        string msg = "Section " ~ section ~ " already exists.";
-        m_section = section;
-        super(msg);
-    }
+   this(string section) @safe pure
+   {
+      const msg = "Section " ~ section ~ " already exists.";
+      m_section = section;
+      super(msg);
+   }
 
-    string section()
-    {
-        return m_section;
-    }
+   string section() const @safe pure
+   {
+      return m_section;
+   }
 }
 
 ///
@@ -73,62 +73,67 @@ public class DuplicateSectionException : Exception
 ///
 public class DuplicateOptionException : Exception
 {
-    private string m_option;
-    private string m_section;
+   private string m_option;
+   private string m_section;
 
-    this(string option, string section) @safe pure
-    {
-	string msg = "Option " ~ option ~ " in section " ~ section ~
-	    " already exists.";
-	m_option = option;
-	m_section = section;
-	super(msg);
-    }
+   this(string option, string section) @safe pure
+   {
+      const msg = "Option " ~ option ~ " in section " ~ section ~ " already exists.";
+      m_option = option;
+      m_section = section;
+      super(msg);
+   }
 
-    string option()
-    {
-	return m_option;
-    }
+   string option() const @safe pure
+   {
+      return m_option;
+   }
 
-    string section()
-    {
-	return m_section;
-    }
+   string section() const @safe pure
+   {
+      return m_section;
+   }
 }
 
 public class NoSectionException : Exception
 {
-    private string m_section;
+   private string m_section;
 
-    this(string section) @safe pure
-    {
-        string msg = "Section '" ~ section ~ "' does not exist.";
-        m_section = section;
-        super(msg);
-    }
+   this(string section) @safe pure
+   {
+      const msg = "Section '" ~ section ~ "' does not exist.";
+      m_section = section;
+      super(msg);
+   }
 
-    string section()
-    {
-        return m_section;
-    }
+   string section() const @safe pure
+   {
+      return m_section;
+   }
 }
 
 public class NoOptionException : Exception
 {
-    private string m_section;
-    private string m_option;
+   private string m_section;
+   private string m_option;
 
-    this(string section, string option) @safe pure
-    {
-        string msg = "Section '" ~ section ~ "' does not have option '" ~
-            option ~ "'.";
-        m_section = section;
-        m_option = option;
-        super(msg);
-    }
+   this(string section, string option) @safe pure
+   {
+      const msg = "Section '" ~ section ~ "' does not have option '" ~ option ~ "'.";
+      m_section = section;
+      m_option = option;
+      super(msg);
+   }
+
+   string section() const @safe pure
+   {
+      return m_section;
+   }
 
-    string section() { return m_section; }
-    string option() { return m_option; }
+   string option() const @safe pure
+   {
+      return m_option;
+   }
 }
 
 /**
@@ -155,308 +160,336 @@ public class ConfigParser
       m_strict = strict;
    }
 
-    /**
-     * Return an array containing the available sections.
-     */
-    string[] sections() @safe pure
-    {
-        return m_sections.keys();
-    }
+   /**
+    * Return an array containing the available sections.
+    */
+   string[] sections() const @safe pure
+   {
+      return m_sections.keys();
+   }
 
-    ///
-    @safe pure unittest
-    {
-        auto conf = new ConfigParser();
+   ///
+   @safe pure unittest
+   {
+      auto conf = new ConfigParser();
 
-        assert(0 == conf.sections().length);
+      assert(0 == conf.sections().length);
 
-        conf.addSection("Section");
+      conf.addSection("Section");
 
-        assert(1 == conf.sections().length);
-    }
+      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) @safe pure
-    {
-        if (section in m_sections)
-            throw new DuplicateSectionException(section);
-        m_sections[section] = null;
-    }
+   /**
+   * Add a section named `section` to the instance.
+   *
+   * Throws:
+   *   - DuplicateSectionError if a section by the given name already
+   * exists.
+   */
+   void addSection(string section) @safe pure
+   {
+      if (section in m_sections)
+      {
+         throw new DuplicateSectionException(section);
+      }
+      m_sections[section] = null;
+   }
 
-    ///
-    unittest
-    {
-        import std.exception : assertNotThrown, assertThrown;
+   ///
+   unittest
+   {
+      import std.exception : assertNotThrown, assertThrown;
 
-        auto conf = new ConfigParser();
+      auto conf = new ConfigParser();
 
-        /* doesn't yet exist */
-        assertNotThrown!DuplicateSectionException(conf.addSection("sample"));
-        /* already exists */
-        assertThrown!DuplicateSectionException(conf.addSection("sample"));
-    }
+      /* 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) @safe pure
-    {
-        auto exists = (section in m_sections);
-        return (exists !is null);
-    }
+   /**
+   * 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) @safe pure const
+   {
+      return (section in m_sections) !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.");
-    }
+   ///
+   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) @safe pure
-    {
-        if (false == this.hasSection(section))
-            throw new NoSectionException(section);
-        return m_sections[section].keys();
-    }
+   string[] options(string section) @safe pure const
+   {
+      if (false == this.hasSection(section))
+      {
+         throw new NoSectionException(section);
+      }
+      return m_sections[section].keys();
+   }
 
-    ///
-    unittest
-    {
-        import std.exception : assertNotThrown, assertThrown;
+   ///
+   unittest
+   {
+      import std.exception : assertNotThrown, assertThrown;
 
-        auto conf = new ConfigParser();
+      auto conf = new ConfigParser();
 
-        conf.addSection("Settings");
+      conf.addSection("Settings");
 
-        assertNotThrown!NoSectionException(conf.options("Settings"));
-        assertThrown!NoSectionException(conf.options("void"));
+      assertNotThrown!NoSectionException(conf.options("Settings"));
+      assertThrown!NoSectionException(conf.options("void"));
 
-        string[] options = conf.options("Settings");
-        assert(0 == options.length, "More keys than we need");
-    }
+      string[] options = conf.options("Settings");
+      assert(0 == options.length, "More keys than we need");
+   }
 
-    bool hasOption(string section, string option) @safe pure
-    {
-        import std.string : toLower;
+   bool hasOption(string section, string option) @safe pure const
+   {
+      import std.string : toLower;
 
-        if (false == this.hasSection(section))
-            return false;
+      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;
-    }*/
+      const lowercaseOption = toLower(option);
+      return (lowercaseOption in m_sections[section]) !is null;
+   }
 
-    void read(string filename)
-    {
-        File file = File(filename, "r");
-        scope(exit) { file.close(); }
-        read(file, false);
-    }
+   /*
+   string[] read(string[] filenames)
+   {
+      return null;
+   }*/
 
-    ///
-    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");
-    }
+   void read(string filename) @safe
+   {
+      File file = File(filename, "r");
+      scope(exit) { file.close(); }
+      read(file, false);
+   }
 
-    /**
-     * 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;
+   ///
+   unittest
+   {
+      import std.file : remove;
+      import std.stdio : File;
 
-        scope(exit) { if (close) file.close(); }
+      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();
 
-        string[] lines = file.byLineCopy.array;
+      auto conf = new ConfigParser();
+      conf.read("test.conf");
 
-        for (auto i = 0; i < lines.length; i++) {
-            string line = lines[i].strip();
+      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'");
 
-            if (line == "")
-                continue;
+      remove("test.conf");
+   }
 
-            if ('[' == lines[i][0]) {
-                parseSectionHeader(lines[i]);
-            } else if (false == canFind(m_commentPrefixes, lines[i][0])) {
-                parseLine(lines[i]);
-            }
-            /* ignore comments */
-        }
-    }
+   /**
+    * 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) @trusted
+   {
+      import std.array : array;
+      import std.algorithm.searching : canFind;
+      import std.string : strip;
 
-  /*void readString(string str)
-    {
-    }*/
+      scope(exit)
+      {
+         if (close)
+         {
+            file.close();
+         }
+      }
 
-    /**
-     * 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;
+      /// XXX: Can this be change to foreach(lin; file.byLine) ?
+      string[] lines = file.byLineCopy.array;
 
-        scope lowercaseOption = toLower(option);
+      for (auto i = 0; i < lines.length; i++)
+      {
+         string line = lines[i].strip();
 
-        if (false == this.hasSection(section))
-            throw new NoSectionException(section);
+         if (line == "")
+         {
+            continue;
+         }
 
-        if (false == this.hasOption(section, lowercaseOption))
-            throw new NoOptionException(section, lowercaseOption);
+         if ('[' == lines[i][0])
+         {
+            parseSectionHeader(lines[i]);
+         }
+         else if (false == canFind(m_commentPrefixes, lines[i][0]))
+         {
+            parseLine(lines[i]);
+         }
+         /* ignore comments */
+      }
+   }
 
-        return m_sections[section][lowercaseOption];
-    }
+   /*void readString(string str)
+   {
+   }*/
 
-    ///
-    unittest
-    {
-        import std.exception : assertThrown;
+   /**
+    * 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) @safe pure const
+   {
+      import std.string : toLower;
 
-        auto conf = new ConfigParser();
-        conf.addSection("Section");
-        conf.set("Section", "option", "value");
+      const lowercaseOption = toLower(option);
 
-        assert(conf.get("Section", "option") == "value");
-        assertThrown!NoSectionException(conf.get("section", "option"));
-        assertThrown!NoOptionException(conf.get("Section", "void"));
-    }
+      if (false == this.hasSection(section))
+      {
+         throw new NoSectionException(section);
+      }
 
-    /// Ditto
-    string get(string section, string option, string fallback)
-    {
-        string res = fallback;
+      if (false == this.hasOption(section, lowercaseOption))
+      {
+         throw new NoOptionException(section, lowercaseOption);
+      }
 
-        try {
-            res = get(section, option);
-        } catch (NoSectionException e) {
-            return res;
-        } catch (NoOptionException e) {
-            return res;
-        }
+      return m_sections[section][lowercaseOption];
+   }
 
-        return res;
-    }
+   ///
+   @safe pure unittest
+   {
+      import std.exception : assertThrown;
 
-    ///
-    unittest
-    {
-        import std.exception : assertThrown;
+      auto conf = new ConfigParser();
+      conf.addSection("Section");
+      conf.set("Section", "option", "value");
 
-        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"));
+   }
 
-        assert("value" == conf.get("Section", "option"));
-        assert("fallback" == conf.get("section", "option", "fallback"));
-        assert("fallback" == conf.get("Section", "void", "fallback"));
+   /// Ditto
+   string get(string section, string option, string fallback) @safe pure const
+   {
+      try
+      {
+         return get(section, option);
+      }
+      catch (NoSectionException e)
+      {
+         return fallback;
+      }
+      catch (NoOptionException e)
+      {
+         return fallback;
+      }
+   }
 
-        /* can use null for fallback */
-        assert(null == conf.get("section", "option", null));
-        assert(null == conf.get("Section", "void", null));
-    }
+   ///
+   @safe pure unittest
+   {
+      import std.exception : assertThrown;
 
-    /**
-     * 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;
+      auto conf = new ConfigParser();
+      conf.addSection("Section");
+      conf.set("Section", "option", "value");
 
-        string res;
+      assert("value" == conf.get("Section", "option"));
+      assert("fallback" == conf.get("section", "option", "fallback"));
+      assert("fallback" == conf.get("Section", "void", "fallback"));
 
-        res = get(section, option);
+      /* can use null for fallback */
+      assert(null is conf.get("section", "option", null));
+      assert(null is conf.get("Section", "void", null));
+   }
 
-        return parse!int(res);
-    }
+   /**
+    * 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) @safe pure const
+   {
+      import std.conv : parse;
 
-    /// Ditto
-    int getInt(string section, string option, int fallback)
-    {
-        int res = fallback;
+      auto res = get(section, option);
 
-        try {
-            res = getInt(section, option);
-        } catch (Exception e) {
-            return res;
-        }
+      return parse!int(res);
+   }
 
-        return res;
-    }
+   /// Ditto
+   int getInt(string section, string option, int fallback) @safe pure const
+   {
+      try
+      {
+         return getInt(section, option);
+      }
+      catch (NoSectionException nse)
+      {
+         return fallback;
+      }
+      catch (NoOptionException noe)
+      {
+         return fallback;
+      }
+      catch (ConvException ce)
+      {
+         return fallback;
+      }
+   }
 
     /*
     double getDouble(string section, string option)
@@ -475,217 +508,234 @@ public class ConfigParser
     {
     }*/
 
-    /**
-     * 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");
-        }
-    }
+   /**
+    * 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) @safe pure const
+   {
+      import std.string : toLower;
 
-    /// Ditto
-    bool getBool(string section, string option, bool fallback)
-    {
-        try {
-            return getBool(section, option);
-        } catch (Exception e) {
-            return fallback;
-        }
-    }
+      const value = get(section, option).toLower;
+
+      switch (value)
+      {
+      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) @safe pure const
+   {
+      try
+      {
+         return getBool(section, option);
+      }
+      catch (NoSectionException e)
+      {
+         return fallback;
+      }
+      catch (NoOptionException e)
+      {
+         return fallback;
+      }
+      catch (ConvException 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);
-        }
+   /**
+    * 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) @safe pure
+   {
+      if ((section in m_sections) is null)
+      {
+         throw new NoSectionException(section);
+      }
 
-        if (option in m_sections[section]) {
-            m_sections[section].remove(option);
-            return true;
-        }
+      if (option in m_sections[section])
+      {
+         m_sections[section].remove(option);
+         return true;
+      }
 
-        return false;
-    }
+      return false;
+   }
 
-    ///
-    unittest
-    {
-        import std.exception : assertThrown;
+   ///
+   @safe pure unittest
+   {
+      import std.exception : assertThrown;
 
-        auto conf = new ConfigParser();
-        conf.addSection("Default");
-        conf.set("Default", "exists", "true");
+      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"));
-    }
+      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;
-    }
+   /**
+    * 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) @safe pure
+   {
+      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"));
-    }
+   ///
+   @safe pure 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) @safe pure
-    {
-        import std.string : toLower;
+   void set(string section, string option, string value) @safe pure
+   {
+      import std.string : toLower;
+
+      if (false == this.hasSection(section))
+      {
+        throw new NoSectionException(section);
+      }
 
-        if (false == this.hasSection(section))
-            throw new NoSectionException(section);
+      const lowercaseOption = toLower(option);
+      m_sections[section][lowercaseOption] = value;
+   }
 
-        scope lowercaseOption = toLower(option);
-        m_sections[section][lowercaseOption] = value;
-    }
+   ///
+   @safe pure unittest
+   {
+      import std.exception : assertThrown;
 
-    ///
-    unittest
-    {
-        import std.exception : assertThrown;
+      auto conf = new ConfigParser();
 
-        auto conf = new ConfigParser();
+      assertThrown!NoSectionException(conf.set("Section", "option", "value"));
 
-        assertThrown!NoSectionException(conf.set("Section", "option",
-            "value"));
+      conf.addSection("Section");
+      conf.set("Section", "option", "value");
+      assert(conf.get("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) @safe const
+   {
+      const del = spaceAroundDelimiters ? " = " : "=";
 
-    ///
-    /// 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);
-            }
-        }
-    }
+      foreach(const section, const options; m_sections)
+      {
+         file.writefln("[%s]", section);
 
-    ///
-    unittest
-    {
-        import std.file : remove;
-        import std.stdio : File;
+         foreach(const option, const value; options)
+         {
+            file.writefln("%s%s%s", option, del, value);
+         }
+      }
+   }
 
-        auto writer = new ConfigParser();
-        writer.addSection("general");
+   ///
+   @safe unittest
+   {
+      import std.file : remove;
+      import std.stdio : File;
 
-        writer.addSection("GUI");
-        writer.set("GUI", "WINDOW_WIDTH", "848");
-        writer.set("GUI", "WINDOW_HEIGHT", "480");
+      auto writer = new ConfigParser();
+      writer.addSection("general");
 
-        auto file = File("test.ini", "w+");
-        scope(exit) remove(file.name);
-        writer.write(file);
+      writer.addSection("GUI");
+      writer.set("GUI", "WINDOW_WIDTH", "848");
+      writer.set("GUI", "WINDOW_HEIGHT", "480");
 
-        file.rewind();
+      auto file = File("test.ini", "w+");
+      scope(exit) remove(file.name);
+      writer.write(file);
 
-        auto reader = new ConfigParser();
-        reader.read(file);
+      file.rewind();
 
-        assert(reader.hasSection("general"), "reader does not contain general section");
+      auto reader = new ConfigParser();
+      reader.read(file);
 
-        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.hasSection("general"), "reader does not contain general section");
 
-        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)");
-    }
+      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)");
+   }
 
    ///
    /// Write a representation of the configuration to the
@@ -702,14 +752,14 @@ public class ConfigParser
    /// Note: Comments from the original file are not preserved when
    ///       writing the configuration back.
    ///
-   void write(string filename, bool spaceAroundDelimiters = true)
+   void write(string filename, bool spaceAroundDelimiters = true) @safe const
    {
       auto file = File(filename, "w+");
       write(file, spaceAroundDelimiters);
    }
 
    ///
-   unittest
+   @safe unittest
    {
       import std.file : remove;
 
@@ -750,24 +800,25 @@ public class ConfigParser
    /// Note: Comments from the original file are not preserved when
    ///       writing the configuration back.
    ///
-   void write(T)(T buffer, bool spaceAroundDelimiters = true) @safe pure
+   void write(T)(T buffer, bool spaceAroundDelimiters = true) @safe pure const
    if (isOutputRange!(T, string))
    {
       import std.format : format;
 
       const del = spaceAroundDelimiters ? " = " : "=";
 
-      foreach(string section, string[string] options; m_sections)
+      foreach(const section, const options; m_sections)
       {
          buffer.put(format!"[%s]\n"(section));
 
-         foreach(string option, string value; options)
+         foreach(const option, const value; options)
          {
             buffer.put(format!"%s%s%s\n"(option, del, value));
          }
       }
    }
 
+   ///
    @safe pure unittest
    {
       import std.outbuffer : OutBuffer;
@@ -792,86 +843,65 @@ public class ConfigParser
       }
    }
 
-  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();
+private:
 
-	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;
+   void parseSectionHeader(const ref string line) @safe pure
+   {
+      import std.array : appender, assocArray;
 
-	if (option in m_sections[m_currentSection] && m_strict)
-	    throw new DuplicateOptionException(option, m_currentSection);
+      auto sectionHeader = appender!string;
+      /* presume that the last character is ] */
+      sectionHeader.reserve(line.length - 1);
+      string popped = line[1 .. $];
 
-        m_sections[m_currentSection][option] = value;
-    }
+      foreach(const c; popped)
+      {
+         if (c != ']')
+         {
+            sectionHeader.put(c);
+         }
+         else
+         {
+            break;
+         }
+      }
 
-    unittest
-    {
-	import std.exception : assertThrown, assertNotThrown;
-	import std.file : remove;
+      m_currentSection = sectionHeader.data();
 
-	auto f = File("config.cfg", "w+");
-	f.writeln("[section]");
-	f.writeln("option = value");
-	f.writeln("Option = value");
-	f.close();
-	scope(exit) remove("config.cfg");
+      if (m_currentSection in m_sections && m_strict)
+      {
+         throw new DuplicateSectionException(m_currentSection);
+      }
 
-	// Duplicate option
-	scope parser = new ConfigParser();
-	assertThrown!DuplicateOptionException(parser.read("config.cfg"));
+      try
+      {
+         this.addSection(m_currentSection);
+      }
+      catch (DuplicateSectionException)
+      {
+         /* no-op - just making sure the section exists. */
+      }
+   }
 
-	// Duplicate section
-	f = File("config.cfg", "w+");
-	f.writeln("[section]");
-	f.writeln("option = value");
-	f.writeln("[section]");
-	f.close();
+   void parseLine(const ref string line) @safe pure
+   {
+      import std.string : indexOfAny, toLower, strip;
 
-	assertThrown!DuplicateSectionException(parser.read("config.cfg"));
+      const idx = line.indexOfAny(m_delimiters);
 
-	// not strict
-	scope relaxedParser = new ConfigParser(['='], [], false);
+      if (-1 == idx)
+      {
+         return;
+      }
 
-	assertNotThrown!DuplicateSectionException(relaxedParser.read("config.cfg"));
-	assert(relaxedParser.hasSection("section"));
+      const option = line[0 .. idx].dup.strip.toLower;
+      const string value = line[idx + 1 .. $].dup.strip;
 
-	f = File("config.cfg", "a+");
-	f.writeln("option = newValue");
-	f.close();
+      if (option in m_sections[m_currentSection] && m_strict)
+      {
+         throw new DuplicateOptionException(option, m_currentSection);
+      }
 
-	assertNotThrown!DuplicateOptionException(relaxedParser.read("config.cfg"));
-	assert(relaxedParser.get("section", "option") == "newValue");
-    }
+      m_sections[m_currentSection][option] = value;
+   }
 }