README.md

@@ -31,9 +31,9 @@ This should output something like the following:
 
 ![](example.png)
 
-Various [styles](https://gogga.dpldocs.info/v3.0.1/gogga.core.GoggaMode.html) are supported which can be set using `mode(GoggaMode)`.
+Various [styles](https://gogga.dpldocs.info/v2.2.1/gogga.transform.GoggaMode.html) are supported which can be set using `mode(GoggaMode)`.
 
 ---
 
-Or you can also [View the full API](https://gogga.dpldocs.info/v3.0.1/gogga.html).
+Or you can also [View the full API](https://gogga.dpldocs.info/v2.2.1/index.html).
 

dub.json

@@ -5,7 +5,7 @@
 	],
 	"copyright": "Copyright © 2023, Tristan B. Kildaire",
 	"dependencies": {
-		"dlog": ">=1.0.0"
+		"dlog": ">=0.3.19"
 	},
 	"description": "Simple VT100 colourised pretty-printing logger",
 	"license": "LGPL 3.0",

source/gogga/context.d

@@ -0,0 +1,14 @@
+/** 
+ * Custom context for gogga logging
+ */
+module gogga.context;
+
+import dlog;
+
+/** 
+ * Pass in a custom context to be used for gogga
+ */
+public final class GoggaContext : Context
+{
+    // TODO: Put more advanced stuff here
+}

source/gogga/core.d

@@ -1,258 +1,26 @@
 /** 
- * Core routines and types
+ * Logging facilities
- *
- * Authors: Tristan Brice Velloza Kildaire (deavmi)
  */
 module gogga.core;
 
-import dlog.core;
+import dlog;
-import dlog.basic;
-import std.conv : to;
 import dlog.utilities : flatten;
 import std.array : join;
 
+import gogga.transform;
+import gogga.context;
+
 /** 
- * The gogga styles supported
+ * The logging class which provides the logging print
+ * calls, controlling of style and whether to debug or
+ * not
  */
-public enum GoggaMode
+public class GoggaLogger : Logger
 {
 	/** 
-     * TwoKTwenty3 is: `[<file>] (<module>:<lineNumber>) <message>`
+	 * The custom transformer
 	 */
-    TwoKTwenty3,
+    private GoggaTransform gTransform = new GoggaTransform();
-
-    /** 
-     * Simple mode is just: `[<LEVEL>] <message>`
-     */
-    SIMPLE,
-
-    /** 
-     * Rustacean mode is: `[<LEVEL>] (<filePath>/<functionName>:<lineNumber>) <message>`
-     */
-    RUSTACEAN,
-
-    /** 
-     * Simple rustacean mode is: `[<LEVEL>] (<functionName>:<lineNumber>) <message>`
-     */
-    RUSTACEAN_SIMPLE
-}
-
-/**
- * Information obtained during compilation time (if any)
- */
-private struct GoggaCompInfo
-{
-    /**
-     * compile time usage file
-     */
-    public string fullFilePath;
-
-    /** 
-     * compile time usage file (relative)
-     */
-    public string file;
-
-    /** 
-     * compile time usage line number
-     */
-    public ulong line;
-
-    /** 
-     * compile time usage module
-     */
-    public string moduleName;
-
-    /** 
-     * compile time usage function
-     */
-    public string functionName;
-
-    /**
-     * compile time usage function (pretty)
-     */
-    public string prettyFunctionName;
-
-    /** 
-     * Constructs the compilation information with the provided
-     * parameters
-     *
-     * Params:
-     *   __FILE_FULL_PATH__ = compile time usage file
-	 *   __FILE__ = compile time usage file (relative)
-	 *   __LINE__ = compile time usage line number
-	 *   __MODULE__ = compile time usage module
-	 *   __FUNCTION__ = compile time usage function
-	 *   __PRETTY_FUNCTION__ = compile time usage function (pretty)
-     */
-    this(string fullFilePath, string file, ulong line, string moduleName, string functionName, string prettyFunctionName)
-    {
-        this.fullFilePath = fullFilePath;
-        this.file = file;
-        this.line = line;
-        this.moduleName = moduleName;
-        this.functionName = functionName;
-        this.prettyFunctionName = prettyFunctionName;
-    }
-
-    /** 
-     * Flattens the known compile-time information into a string array
-     *
-     * Returns: a string[]
-     */
-    public string[] toArray()
-    {
-        return [fullFilePath, file, to!(string)(line), moduleName, functionName, prettyFunctionName];
-    }
-}
-
-/** 
- * A `GoggaMessage` which comprises
- * of a `GoggaCompInfo` for context
- */
-private class GoggaMessage : BasicMessage
-{
-    /** 
-     * The line information
-     */
-    private GoggaCompInfo ctx;
-
-    /** 
-     * Sets the context
-     *
-     * Params:
-     *   ctx = the context
-     */
-    public void setContext(GoggaCompInfo ctx)
-    {
-        this.ctx = ctx;
-    }
-
-    /** 
-     * Returns the context
-     *
-     * Returns: the context
-     */
-    public GoggaCompInfo getContext()
-    {
-        return this.ctx;
-    }
-}
-
-/** 
- * The Gogga transformer which
- * applies stylization to
- * incoming `GoggaMessage`(s)
- */
-private class GoggaTransform : Transform
-{
-    /** 
-     * Mode to use for stylization
-     */
-    private GoggaMode mode;
-
-    /** 
-     * Sets the stylization to
-     * use when transforming
-     * the message's text
-     *
-     * Params:
-     *   mode = the `GoggaMode`
-     */
-    public void setMode(GoggaMode mode)
-    {
-        this.mode = mode;
-    }
-
-    /** 
-     * Transforms the incoming message
-     * to use the Gogga stylization. This
-     * will be a no-op if the incoming
-     * message is not a `GoggaMessage`.
-     *
-     * Params:
-     *   message = the message to transform
-     * Returns: the transformed message,
-     * else the same exact one
-     */
-    public Message transform(Message message)
-    {
-        // Only handle GoggaMessage(s)
-        GoggaMessage goggaMesg = cast(GoggaMessage)message;
-        if(goggaMesg is null)
-        {
-            return null;
-        }
-
-        /* The generated output string */
-        string finalOutput;
-
-
-
-        /* Extract the Level */
-        Level level = goggaMesg.getLevel();
-
-        /* Extract the text */
-        string text = goggaMesg.getText();
-
-        /* get the context data */
-        string[] context = goggaMesg.getContext().toArray();
-
-
-        /** 
-         * Simple mode is just: `[<LEVEL>] <message>`
-         */
-        if(this.mode == GoggaMode.SIMPLE)
-        {
-            finalOutput = cast(string)debugColor("["~to!(string)(level)~"] ", level);
-
-            finalOutput ~= text~"\n";
-        }
-        /** 
-         * TwoKTwenty3 is: `[<file>] (<module>:<lineNumber>) <message>`
-         */
-        else if(this.mode == GoggaMode.TwoKTwenty3)
-        {
-            /* Module information (and status debugColoring) */
-            string moduleInfo = cast(string)debugColor("["~context[1]~"]", level);
-            
-            /* Function and line number info */
-            string funcInfo = cast(string)(colorSrc("("~context[4]~":"~context[2]~")"));
-
-            finalOutput =  moduleInfo~" "~funcInfo~" "~text~"\n";
-        }
-        /** 
-         * Rustacean mode is: `[<LEVEL>] (<filePath>/<functionName>:<lineNumber>) <message>`
-         */
-        else if(this.mode == GoggaMode.RUSTACEAN)
-        {
-            finalOutput = cast(string)debugColor(to!(string)(level)~"\t", level);
-            finalOutput ~= cast(string)(colorSrc(context[1]~"/"~context[4]~":"~context[2]~"  "));
-            finalOutput ~= text~"\n";
-        }
-        /** 
-         * Simple rustacean mode is: `[<LEVEL>] (<functionName>:<lineNumber>) <message>`
-         */
-        else if(this.mode == GoggaMode.RUSTACEAN_SIMPLE)
-        {
-            finalOutput = cast(string)debugColor(to!(string)(level)~"\t", level);
-            finalOutput ~= cast(string)(colorSrc(context[4]~":"~context[2]~"  "));
-            finalOutput ~= text~"\n";
-        }
-
-        goggaMesg.setText(finalOutput);
-        return message;
-    }
-}
-
-/** 
- * A `GoggaLogger`
- */
-public final class GoggaLogger : BasicLogger
-{
-    /** 
-     * The Gogga text transformer
-     */
-    private GoggaTransform gogTrans;
 
 	/** 
 	 * Whether debug prints are enabled or not
@@ -260,58 +28,34 @@ public final class GoggaLogger : BasicLogger
     private bool debugEnabled = false;
 
 	/** 
-     * Constructs a new `GoggaLogger`
+	 * Constructs a new GoggaLOgger
 	 */
     this()
     {
-        super();
+        super(gTransform);
-        this.gogTrans = new GoggaTransform();
-        addTransform(this.gogTrans);
     }
     
 	/** 
-     * Sets the style of logging
+	 * Our underlying logging implementation
-     * to use
 	 *
 	 * Params:
-     *   mode = the `GoggaMode`
+	 *   text = the text to write
+	 */
+    public override void logImpl(string text)
+    {
+        import std.stdio : write;
+        write(text);
+    }
+
+	/** 
+	 * Set the style of print outs
+	 *
+	 * Params:
+	 *   mode = the GoggaMode wanted
 	 */
 	public void mode(GoggaMode mode)
 	{
-        this.gogTrans.setMode(mode);
+		gTransform.setMode(mode);
-    }
-
-    /** 
-     * Performs the actual logging
-     * by packing up everything before
-     * sending it to the `log(Message)`
-     * method
-     *
-     * Params:
-     *   segments = the compile-time segments
-     *   info = the context
-     *   level = the log level to use
-     */
-    private void doLog(TextType...)(TextType segments, GoggaCompInfo info, Level level)
-    {
-        /* Create a new GoggaMessage */
-        GoggaMessage message = new GoggaMessage();
-
-        /* Set context to the line information */
-        message.setContext(info);
-
-        /* Set the level */
-        message.setLevel(level);
-
-        /** 
-         * Grab all compile-time arguments and make them
-         * into an array, then join them together and
-         * set that text as the message's text
-         */
-        message.setText(join(flatten(segments), " "));
-
-        /* Log this message */
-		log(message);
 	}
 
     /** 
@@ -333,7 +77,28 @@ public final class GoggaLogger : BasicLogger
 									string c4 = __MODULE__, string c5 = __FUNCTION__,
 									string c6 = __PRETTY_FUNCTION__)
 	{
-		doLog(segments, GoggaCompInfo(c1, c2, c3, c4, c5, c6), Level.ERROR);
+		/* Use the context `GoggaContext` */
+		GoggaContext defaultContext = new GoggaContext();
+
+		/* Build up the line information */
+		CompilationInfo compilationInfo = CompilationInfo(c1, c2, c3, c4, c5, c6);
+
+		/* Set the line information in the context */
+		defaultContext.setLineInfo(compilationInfo);
+
+		/* Set the level to ERROR */
+		defaultContext.setLevel(Level.ERROR);
+
+		/**
+		 * Grab at compile-time all arguments and generate runtime code to add them to `components`
+		 */		
+		string[] components = flatten(segments);
+
+		/* Join all `components` into a single string */
+		string messageOut = join(components, multiArgJoiner);
+
+		/* Call the log */
+		logc(defaultContext, messageOut, c1, c2, c3, c4, c5, c6);
 	}
 
 	/** 
@@ -355,7 +120,28 @@ public final class GoggaLogger : BasicLogger
 									string c4 = __MODULE__, string c5 = __FUNCTION__,
 									string c6 = __PRETTY_FUNCTION__)
 	{
-		doLog(segments, GoggaCompInfo(c1, c2, c3, c4, c5, c6), Level.INFO);
+		/* Use the context `GoggaContext` */
+		GoggaContext defaultContext = new GoggaContext();
+
+		/* Build up the line information */
+		CompilationInfo compilationInfo = CompilationInfo(c1, c2, c3, c4, c5, c6);
+
+		/* Set the line information in the context */
+		defaultContext.setLineInfo(compilationInfo);
+
+		/* Set the level to INFO */
+		defaultContext.setLevel(Level.INFO);
+
+		/**
+		 * Grab at compile-time all arguments and generate runtime code to add them to `components`
+		 */		
+		string[] components = flatten(segments);
+
+		/* Join all `components` into a single string */
+		string messageOut = join(components, multiArgJoiner);
+
+		/* Call the log */
+		logc(defaultContext, messageOut, c1, c2, c3, c4, c5, c6);
 	}
 
 	/** 
@@ -377,7 +163,28 @@ public final class GoggaLogger : BasicLogger
 									string c4 = __MODULE__, string c5 = __FUNCTION__,
 									string c6 = __PRETTY_FUNCTION__)
 	{
-        doLog(segments, GoggaCompInfo(c1, c2, c3, c4, c5, c6), Level.WARN);
+		/* Use the context `GoggaContext` */
+		GoggaContext defaultContext = new GoggaContext();
+
+		/* Build up the line information */
+		CompilationInfo compilationInfo = CompilationInfo(c1, c2, c3, c4, c5, c6);
+
+		/* Set the line information in the context */
+		defaultContext.setLineInfo(compilationInfo);
+
+		/* Set the level to WARN */
+		defaultContext.setLevel(Level.WARN);
+
+		/**
+		 * Grab at compile-time all arguments and generate runtime code to add them to `components`
+		 */		
+		string[] components = flatten(segments);
+
+		/* Join all `components` into a single string */
+		string messageOut = join(components, multiArgJoiner);
+
+		/* Call the log */
+		logc(defaultContext, messageOut, c1, c2, c3, c4, c5, c6);
 	}
 
 	/** 
@@ -400,100 +207,64 @@ public final class GoggaLogger : BasicLogger
 									string c4 = __MODULE__, string c5 = __FUNCTION__,
 									string c6 = __PRETTY_FUNCTION__)
 	{
-        doLog(segments, GoggaCompInfo(c1, c2, c3, c4, c5, c6), Level.DEBUG);
+		/* Only debug if debugging is enabled */
+		if(debugEnabled)
+		{
+			/* Use the context `GoggaContext` */
+			GoggaContext defaultContext = new GoggaContext();
+
+			/* Build up the line information */
+			CompilationInfo compilationInfo = CompilationInfo(c1, c2, c3, c4, c5, c6);
+
+			/* Set the line information in the context */
+			defaultContext.setLineInfo(compilationInfo);
+
+			/* Set the level to DEBUG */
+			defaultContext.setLevel(Level.DEBUG);
+
+			/**
+			* Grab at compile-time all arguments and generate runtime code to add them to `components`
+			*/		
+			string[] components = flatten(segments);
+
+			/* Join all `components` into a single string */
+			string messageOut = join(components, multiArgJoiner);
+
+			/* Call the log */
+			logc(defaultContext, messageOut, c1, c2, c3, c4, c5, c6);
+		}
 	}
 
 	/** 
 	 * Alias for debug_
 	 */
 	public alias dbg = debug_;
+
+	/** 
+	 * Enables debug prints
+	 */
+    public void enableDebug()
+    {
+        this.debugEnabled = true;
 	}
 
 	/** 
- * Colorise the text provided accoridng to the level and then
+	 * Disables debug prints
- * reset the colors at the end
- *
- * Params:
- *   text = the text to colorise
- *   level = the color to use
- * Returns: the byte sequence of characters and controls
 	 */
-private byte[] debugColor(string text, Level level)
+    public void disableDebug()
     {
-    /* The generated message */
+        this.debugEnabled = false;
-    byte[] messageBytes;
-
-    /* If INFO, set green */
-    if(level == Level.INFO)
-    {
-        messageBytes = cast(byte[])[27, '[','3','2','m'];
     }
-    /* If WARN, set yellow */
-    else if(level == Level.WARN)
-    {
-        messageBytes = cast(byte[])[27, '[','3','1', ';', '9', '3', 'm'];
-    }
-    /* If ERROR, set red */
-    else if(level == Level.ERROR)
-    {
-        messageBytes = cast(byte[])[27, '[','3','1','m'];
-    }
-    /* If DEBUG, set pink */
-    else
-    {
-        messageBytes = cast(byte[])[27, '[','3','5','m'];
-    }
-
-    /* Add the message */
-    messageBytes ~= cast(byte[])text;
-
-    /* Switch back debugColor */
-    messageBytes ~= cast(byte[])[27, '[', '3', '9', 'm'];
-
-    /* Reset coloring */
-    messageBytes ~= [27, '[', 'm'];
-
-    return messageBytes;
-}
-
-/** 
- * Colors the provided text in a gray fashion and then
- * resets back to normal
- *
- * Params:
- *   text = the text to gray color
- * Returns: the byte sequence of characters and controls
- */
-private byte[] colorSrc(string text)
-{
-    /* The generated message */
-    byte[] messageBytes;
-
-    /* Reset coloring */
-    messageBytes ~= [27, '[', 'm'];
-
-    /* Color gray */
-    messageBytes ~= [27, '[', '3', '9', ';', '2', 'm'];
-
-    /* Append the message */
-    messageBytes ~= text;
-
-    /* Reset coloring */
-    messageBytes ~= [27, '[', 'm'];
-
-    return messageBytes;
 }
 
 version(unittest)
 {
-	import std.stdio : writeln, stdout;
+	import std.stdio : writeln;
 }
 
 unittest
 {
     GoggaLogger gLogger = new GoggaLogger();
-    gLogger.addHandler(new FileHandler(stdout));
-    gLogger.setLevel(Level.INFO);
 
 	// Test the normal modes
     gLogger.info("This is an info message");
@@ -504,7 +275,7 @@ unittest
 	gLogger.dbg("This is a debug which is hidden", 1);
 
 	// Now enable debugging and you should see it
-	gLogger.setLevel(Level.DEBUG);
+	gLogger.enableDebug();
 	gLogger.dbg("This is a VISIBLE debug", true);
 
     // Make space between unit tests
@@ -514,9 +285,6 @@ unittest
 unittest
 {
     GoggaLogger gLogger = new GoggaLogger();
-    gLogger.addHandler(new FileHandler(stdout));
-    gLogger.setLevel(Level.INFO);
-
 	gLogger.mode(GoggaMode.TwoKTwenty3);
 
     // Test the normal modes
@@ -528,7 +296,7 @@ unittest
 	gLogger.dbg("This is a debug which is hidden", 1);
 
 	// Now enable debugging and you should see it
-    gLogger.setLevel(Level.DEBUG);
+	gLogger.enableDebug();
 	gLogger.dbg("This is a VISIBLE debug", true);
 
     // Make space between unit tests
@@ -538,9 +306,6 @@ unittest
 unittest
 {
     GoggaLogger gLogger = new GoggaLogger();
-    gLogger.addHandler(new FileHandler(stdout));
-    gLogger.setLevel(Level.INFO);
-
 	gLogger.mode(GoggaMode.SIMPLE);
 
     // Test the normal modes
@@ -552,7 +317,7 @@ unittest
 	gLogger.dbg("This is a debug which is hidden", 1);
 
 	// Now enable debugging and you should see it
-    gLogger.setLevel(Level.DEBUG);
+	gLogger.enableDebug();
 	gLogger.dbg("This is a VISIBLE debug", true);
 
     // Make space between unit tests
@@ -562,9 +327,6 @@ unittest
 unittest
 {
     GoggaLogger gLogger = new GoggaLogger();
-    gLogger.addHandler(new FileHandler(stdout));
-    gLogger.setLevel(Level.INFO);
-
 	gLogger.mode(GoggaMode.RUSTACEAN);
 
     // Test the normal modes
@@ -576,7 +338,7 @@ unittest
 	gLogger.dbg("This is a debug which is hidden", 1);
 
 	// Now enable debugging and you should see it
-    gLogger.setLevel(Level.DEBUG);
+	gLogger.enableDebug();
 	gLogger.dbg("This is a VISIBLE debug", true);
 
     // Make space between unit tests
@@ -586,9 +348,6 @@ unittest
 unittest
 {
     GoggaLogger gLogger = new GoggaLogger();
-    gLogger.addHandler(new FileHandler(stdout));
-    gLogger.setLevel(Level.INFO);
-
 	gLogger.mode(GoggaMode.RUSTACEAN_SIMPLE);
 
     // Test the normal modes
@@ -600,7 +359,7 @@ unittest
 	gLogger.dbg("This is a debug which is hidden", 1);
 
 	// Now enable debugging and you should see it
-    gLogger.setLevel(Level.DEBUG);
+	gLogger.enableDebug();
 	gLogger.dbg("This is a VISIBLE debug", true);
 
     // Make space between unit tests

source/gogga/package.d

@@ -1,14 +1,16 @@
 /**
  * Gogga logging facilities
  */
-/**
- * The Gogga logging library
- *
- * Authors: Tristan Brice Velloza Kildaire (deavmi)
- */
 module gogga;
 
 /** 
- * Core routines and types
+ * The logging class which provides the logging print
+ * calls, controlling of style and whether to debug or
+ * not
  */
-public import gogga.core;
+public import gogga.core : GoggaLogger;
+
+/** 
+ * The gogga styles supported
+ */
+public import gogga.transform : GoggaMode;

source/gogga/transform.d

@@ -0,0 +1,201 @@
+/** 
+ * The custom text transformer that implements the gogga-stylised
+ * logging messages
+ */
+module gogga.transform;
+
+import dlog;
+import gogga.context;
+import std.conv : to;
+
+/** 
+ * The gogga styles supported
+ */
+public enum GoggaMode
+{
+    /** 
+     * TwoKTwenty3 is: `[<file>] (<module>:<lineNumber>) <message>`
+     */
+    TwoKTwenty3,
+
+    /** 
+     * Simple mode is just: `[<LEVEL>] <message>`
+     */
+    SIMPLE,
+
+    /** 
+     * Rustacean mode is: `[<LEVEL>] (<filePath>/<functionName>:<lineNumber>) <message>`
+     */
+    RUSTACEAN,
+
+    /** 
+     * Simple rustacean mode is: `[<LEVEL>] (<functionName>:<lineNumber>) <message>`
+     */
+    RUSTACEAN_SIMPLE
+}
+
+/** 
+ * The custom gogga text transformer
+ */
+public class GoggaTransform : MessageTransform
+{
+    /** 
+     * Current style
+     */
+    private GoggaMode mode;
+
+    /** 
+     * Transforms the provided text
+     *
+     * Params:
+     *   text = text to transform
+     *   ctx = the context passed in
+     * Returns: a string of transformed text
+     */
+    public override string transform(string text, Context ctx)
+    {
+        /* The generated output string */
+        string finalOutput;
+
+
+        /* Get the GoggaContext */
+        GoggaContext gCtx = cast(GoggaContext)ctx;
+
+        /* Extract the line information */
+        CompilationInfo compInfo = gCtx.getLineInfo();
+        string[] context = compInfo.toArray();
+
+        /* Extract the Level */
+        Level level = gCtx.getLevel();
+
+
+        /** 
+         * Simple mode is just: `[<LEVEL>] <message>`
+         */
+        if(mode == GoggaMode.SIMPLE)
+        {
+            finalOutput = cast(string)debugColor("["~to!(string)(level)~"] ", level);
+
+            finalOutput ~= text~"\n";
+        }
+        /** 
+         * TwoKTwenty3 is: `[<file>] (<module>:<lineNumber>) <message>`
+         */
+        else if(mode == GoggaMode.TwoKTwenty3)
+        {
+            /* Module information (and status debugColoring) */
+            string moduleInfo = cast(string)debugColor("["~context[1]~"]", level);
+            
+            /* Function and line number info */
+            string funcInfo = cast(string)(colorSrc("("~context[4]~":"~context[2]~")"));
+
+            finalOutput =  moduleInfo~" "~funcInfo~" "~text~"\n";
+        }
+        /** 
+         * Rustacean mode is: `[<LEVEL>] (<filePath>/<functionName>:<lineNumber>) <message>`
+         */
+        else if(mode == GoggaMode.RUSTACEAN)
+        {
+            finalOutput = cast(string)debugColor(to!(string)(level)~"\t", level);
+            finalOutput ~= cast(string)(colorSrc(context[1]~"/"~context[4]~":"~context[2]~"  "));
+            finalOutput ~= text~"\n";
+        }
+        /** 
+         * Simple rustacean mode is: `[<LEVEL>] (<functionName>:<lineNumber>) <message>`
+         */
+        else if(mode == GoggaMode.RUSTACEAN_SIMPLE)
+        {
+            finalOutput = cast(string)debugColor(to!(string)(level)~"\t", level);
+            finalOutput ~= cast(string)(colorSrc(context[4]~":"~context[2]~"  "));
+            finalOutput ~= text~"\n";
+        }
+
+        return finalOutput;
+    }
+
+    /** 
+     * Set the gogga style
+     *
+     * Params:
+     *   mode = the GoggaMode to use
+     */
+    public void setMode(GoggaMode mode)
+    {
+        this.mode = mode;
+    }
+}
+
+/** 
+ * Colorise the text provided accoridng to the level and then
+ * reset the colors at the end
+ *
+ * Params:
+ *   text = the text to colorise
+ *   level = the color to use
+ * Returns: the byte sequence of characters and controls
+ */
+private byte[] debugColor(string text, Level level)
+{
+    /* The generated message */
+    byte[] messageBytes;
+
+    /* If INFO, set green */
+    if(level == Level.INFO)
+    {
+        messageBytes = cast(byte[])[27, '[','3','2','m'];
+    }
+    /* If WARN, set yellow */
+    else if(level == Level.WARN)
+    {
+        messageBytes = cast(byte[])[27, '[','3','1', ';', '9', '3', 'm'];
+    }
+    /* If ERROR, set red */
+    else if(level == Level.ERROR)
+    {
+        messageBytes = cast(byte[])[27, '[','3','1','m'];
+    }
+    /* If DEBUG, set pink */
+    else
+    {
+        messageBytes = cast(byte[])[27, '[','3','5','m'];
+    }
+
+    /* Add the message */
+    messageBytes ~= cast(byte[])text;
+
+    /* Switch back debugColor */
+    messageBytes ~= cast(byte[])[27, '[', '3', '9', 'm'];
+
+    /* Reset coloring */
+    messageBytes ~= [27, '[', 'm'];
+
+    return messageBytes;
+}
+
+/** 
+ * Colors the provided text in a gray fashion and then
+ * resets back to normal
+ *
+ * Params:
+ *   text = the text to gray color
+ * Returns: the byte sequence of characters and controls
+ */
+private byte[] colorSrc(string text)
+{
+    /* The generated message */
+    byte[] messageBytes;
+
+    /* Reset coloring */
+    messageBytes ~= [27, '[', 'm'];
+
+    /* Color gray */
+    messageBytes ~= [27, '[', '3', '9', ';', '2', 'm'];
+
+    /* Append the message */
+    messageBytes ~= text;
+
+    /* Reset coloring */
+    messageBytes ~= [27, '[', 'm'];
+
+    return messageBytes;
+}