Switched to dependency injection for console use.

Created interfaces for input and output for better structure and easier testing.

RecrownedGTK.Tools/CommandProcessor/CommandEngine.cs

@@ -14,25 +14,25 @@ namespace RecrownedGTK.Tools.CommandProcessor
             commands = new List<EngineCommand>();
         }
 
-        public void Run(IUserInput input)
+        public void Run(IUserInput input, IUserOutput output)
         {
             while (running)
             {
-                ConsoleUtilities.WriteWrappedLine("\nAwaiting command.");
+                output.WrappedOutput("\nAwaiting command.");
                 string command = input.GetInput();
                 try
                 {
-                    Process(command);
+                    Process(input, output, command);
 
                 }
                 catch (ArgumentException ae)
                 {
-                    ConsoleUtilities.WriteWrappedLine("Error: " + ae.Message);
+                    output.WrappedOutput("Error: " + ae.Message);
                 }
             }
         }
 
-        public void Process(string commandAndArguments)
+        public void Process(IUserInput userInput, IUserOutput userOutput, string commandAndArguments)
         {
             string command = commandAndArguments;
             string[] arguments = null;
@@ -72,7 +72,7 @@ namespace RecrownedGTK.Tools.CommandProcessor
                 arguments = argumentsList.ToArray();
             }
             if (!ContainsCommand(command)) throw new ArgumentException("Command not found. Type \"help\" for a list of commands.");
-            GetCommand(command).Run(arguments);
+            GetCommand(command).Run(userInput, userOutput, arguments);
         }
 
         public bool ContainsCommand(string command)

RecrownedGTK.Tools/CommandProcessor/Commands/ClearConsoleCommand.cs

@@ -9,9 +9,9 @@ namespace RecrownedGTK.Tools.CommandProcessor.Commands
             help = "Clears the console.";
         }
 
-        public override void Run(string[] arguments = null)
+        public override void Run(IUserInput userInput, IUserOutput userOutput, string[] arguments = null)
         {
-            Console.Clear();
+            userOutput.ClearOutput();
         }
     }
 }

RecrownedGTK.Tools/CommandProcessor/Commands/HelpCommand.cs

@@ -13,16 +13,16 @@ namespace RecrownedGTK.Tools.CommandProcessor.Commands
         }
 
 
-        public override void Run(string[] arguments)
+        public override void Run(IUserInput userInput, IUserOutput userOutput, string[] arguments)
         {
             if (arguments != null)
             {
                 if (commandEngine.ContainsCommand(arguments[0]))
                 {
-                    if (arguments.Length < 2) ConsoleUtilities.WriteWrappedLine(commandEngine.GetCommand(arguments[0]).Help(null));
+                    if (arguments.Length < 2) userOutput.WrappedOutput(commandEngine.GetCommand(arguments[0]).Help(null));
                     for (int i = 1; i < arguments.Length; i++)
                     {
-                        ConsoleUtilities.WriteWrappedLine(commandEngine.GetCommand(arguments[0]).Help(arguments[i]));
+                        userOutput.WrappedOutput(commandEngine.GetCommand(arguments[0]).Help(arguments[i]));
                     }
                 }
                 else
@@ -32,20 +32,21 @@ namespace RecrownedGTK.Tools.CommandProcessor.Commands
             }
             else
             {
-                ConsoleUtilities.WriteWrappedLine("Tools for RecrownedGTK library. Possible commands are as follows:\n");
+                userOutput.WrappedOutput("Tools for RecrownedGTK library. Possible commands are as follows:\n");
                 foreach (EngineCommand engineCommand in commandEngine.commands)
                 {
                     for (int i = 0; i < engineCommand.InvokeStrings.Length; i++)
                     {
-                        ConsoleUtilities.WriteWrapped(engineCommand.InvokeStrings[i]);
+                        userOutput.WrappedOutput(engineCommand.InvokeStrings[i]);
                         if (i + 1 < engineCommand.InvokeStrings.Length)
                         {
-                            ConsoleUtilities.WriteWrapped(", ");
+                            userOutput.WrappedOutput(", ");
                         }
                     }
-                    ConsoleUtilities.WriteWrapped(" : ");
+                    userOutput.WrappedOutput(" : ");
-                    ConsoleUtilities.WriteWrapped(engineCommand.Help().Replace("\n", "\n\t"), true);
+                    userOutput.WrappedOutput(engineCommand.Help().Replace("\n", "\n\t"));
-                    Console.WriteLine("--------");
+                    userOutput.WrappedOutput("\n");
+                    userOutput.Output("--------");
                 }
             }
         }

RecrownedGTK.Tools/CommandProcessor/Commands/StopCommand.cs

@@ -10,7 +10,7 @@
             help = "Exits the tool.";
         }
 
-        public override void Run(string[] arguments = null)
+        public override void Run(IUserInput userInput, IUserOutput userOutput, string[] arguments = null)
         {
             commandEngine.running = false;
         }

RecrownedGTK.Tools/CommandProcessor/EngineCommand.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using RecrownedGTK.Tools.CommandProcessor;
 
 namespace RecrownedGTK.Tools.CommandProcessor
 {
@@ -51,7 +52,7 @@ namespace RecrownedGTK.Tools.CommandProcessor
         /// Runs the command.
         /// </summary>
         /// <param name="arguments">arguments to be used. May be null.</param>
-        public abstract void Run(string[] arguments = null);
+        public abstract void Run(IUserInput userInput = null, IUserOutput userOutput = null, string[] arguments = null);
 
         /// <summary>
         /// Check if given argument is viable for command.

RecrownedGTK.Tools/CommandProcessor/IUserOutput.cs

@@ -0,0 +1,8 @@
+namespace RecrownedGTK.Tools.CommandProcessor {
+    public interface IUserOutput
+    {
+        void Output(string output);
+        void WrappedOutput(string output);
+        void ClearOutput();
+    }
+}

RecrownedGTK.Tools/ConsoleInterface/ConsoleProgarm.cs

@@ -0,0 +1,68 @@
+using RecrownedGTK.Tools.CommandProcessor;
+using RecrownedGTK.Tools.CommandProcessor.Commands;
+using RecrownedGTK.Tools.NinePatchTools;
+using RecrownedGTK.Tools.TextureAtlasTools;
+using System;
+using System.Reflection;
+using System.Text;
+
+namespace RecrownedGTK.Tools.ConsoleInterface
+{
+    internal class ConsoleProgram
+    {
+        private class ConsoleInput : IUserInput {
+            public string GetInput() {
+                return Console.ReadLine();
+            }
+        }
+
+        private class ConsoleOutput : IUserOutput {
+            public void Output(string output) {
+                Console.WriteLine(output);
+            }
+
+            public void WrappedOutput(string output) {
+                ConsoleUtilities.WrapMessageToConsoleWidth(output);
+            }
+
+            public void ClearOutput() {
+                Console.Clear();
+            }
+        }
+        static void Main(string[] args)
+        {
+            ConsoleInput consoleInput = new ConsoleInput();
+            ConsoleOutput consoleOutput = new ConsoleOutput();
+            CommandEngine ce = new CommandEngine();
+            ConsoleUtilities.WrapMessageToConsoleWidth("Recrowned Athenaeum Console Tools version " + Assembly.GetExecutingAssembly().GetName().Version.ToString());
+            ConsoleUtilities.WrapMessageToConsoleWidth("Type \"help\" for help.");
+
+            ce.commands.Add(new HelpCommand(ce));
+            ce.commands.Add(new TexturePackerCommand());
+            ce.commands.Add(new StopCommand(ce));
+            ce.commands.Add(new ClearConsoleCommand());
+            ce.commands.Add(new NinePatchCommand());
+
+            if (args.Length > 0)
+            {
+                ConsoleUtilities.WrapMessageToConsoleWidth("Executing as one time use.");
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < args.Length; i++) sb.Append(args[i] + ' ');
+                string commandAndArgs = sb.ToString().TrimEnd();
+                try
+                {
+                    ConsoleUtilities.WrapMessageToConsoleWidth("Command and argument received: " + commandAndArgs);
+                    ce.Process(consoleInput, consoleOutput, commandAndArgs);
+                }
+                catch (ArgumentException e)
+                {
+                    ConsoleUtilities.WrapMessageToConsoleWidth("An error has occurred: " + e.Message);
+                }
+            }
+            else
+            {
+                ce.Run(consoleInput, consoleOutput);
+            }
+        }
+    }
+}

RecrownedGTK.Tools/ConsoleInterface/ConsoleUtilities.cs

@@ -1,17 +1,10 @@
 using System;
 using System.Text;
 
-namespace RecrownedGTK.Tools
+namespace RecrownedGTK.Tools.ConsoleInterface
 {
     internal class ConsoleUtilities
     {
-        public static void WriteWrapped(string message, bool line = false)
-        {
-            message = WrapMessageToConsoleWidth(message);
-            if (line) message = message + "\n";
-            Console.Write(message);
-        }
-
         public static string WrapMessageToConsoleWidth(string message)
         {
             string[] words = message.Split(' ');
@@ -39,12 +32,8 @@ namespace RecrownedGTK.Tools
                     stringBuilder.Append(' ');
                 }
             }
+            stringBuilder.AppendLine();
             return stringBuilder.ToString();
         }
-
-        public static void WriteWrappedLine(string message)
-        {
-            WriteWrapped(message, true);
-        }
     }
 }

RecrownedGTK.Tools/NinePatchTools/NinePatchCommand.cs

@@ -23,7 +23,7 @@ namespace RecrownedGTK.Tools.NinePatchTools
             commandArguments[5] = new EngineCommandArgument("-b", "bottom patch.", true);
         }
 
-        public override void Run(string[] arguments = null)
+        public override void Run(IUserInput userInput = null, IUserOutput userOutput = null, string[] arguments = null)
         {
             if (arguments == null) throw new ArgumentException("Missing arguments. Type \"help 9p\" for more information.");
             int leftBound = 0, rightBound = 0, topBound = 0, bottomBound = 0;
@@ -51,8 +51,8 @@ namespace RecrownedGTK.Tools.NinePatchTools
             File.Move(imagePath, modifiedPath);
             File.WriteAllText(outPath + ".9p", serialized);
 
-            ConsoleUtilities.WriteWrappedLine("Done. Written to \"" + outPath + "\" with values: left = " + leftBound + " right = " + rightBound + " top = " + topBound + " bottom = " + bottomBound);
+            userOutput.WrappedOutput("Done. Written to \"" + outPath + "\" with values: left = " + leftBound + " right = " + rightBound + " top = " + topBound + " bottom = " + bottomBound);
-            ConsoleUtilities.WriteWrappedLine("Image renamed to: " + Path.GetFileName(modifiedPath));
+            userOutput.WrappedOutput("Image renamed to: " + Path.GetFileName(modifiedPath));
         }
     }
 }

RecrownedGTK.Tools/Program.cs

@@ -1,52 +0,0 @@
-using RecrownedGTK.Tools.CommandProcessor;
-using RecrownedGTK.Tools.CommandProcessor.Commands;
-using RecrownedGTK.Tools.NinePatchTools;
-using RecrownedGTK.Tools.TextureAtlasTools;
-using System;
-using System.Reflection;
-using System.Text;
-
-namespace RecrownedGTK.Tools
-{
-    internal class Program
-    {
-        private class ConsoleInput : IUserInput {
-            public string GetInput() {
-                return Console.ReadLine();
-            }
-        }
-        static void Main(string[] args)
-        {
-            CommandEngine ce = new CommandEngine();
-            ConsoleUtilities.WriteWrappedLine("Recrowned Athenaeum Console Tools version " + Assembly.GetExecutingAssembly().GetName().Version.ToString());
-            ConsoleUtilities.WriteWrappedLine("Type \"help\" for help.");
-
-            ce.commands.Add(new HelpCommand(ce));
-            ce.commands.Add(new TexturePackerCommand());
-            ce.commands.Add(new StopCommand(ce));
-            ce.commands.Add(new ClearConsoleCommand());
-            ce.commands.Add(new NinePatchCommand());
-
-            if (args.Length > 0)
-            {
-                ConsoleUtilities.WriteWrappedLine("Executing as one time use.");
-                StringBuilder sb = new StringBuilder();
-                for (int i = 0; i < args.Length; i++) sb.Append(args[i] + ' ');
-                string commandAndArgs = sb.ToString().TrimEnd();
-                try
-                {
-                    ConsoleUtilities.WriteWrappedLine("Command and argument received: " + commandAndArgs);
-                    ce.Process(commandAndArgs);
-                }
-                catch (ArgumentException e)
-                {
-                    ConsoleUtilities.WriteWrappedLine("An error has occurred: " + e.Message);
-                }
-            }
-            else
-            {
-                ce.Run(new ConsoleInput());
-            }
-        }
-    }
-}

RecrownedGTK.Tools/TextureAtlasTools/TexturePacker.cs

@@ -7,9 +7,8 @@ using SixLabors.Primitives;
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Security;
-
+using RecrownedGTK.Tools.CommandProcessor;
 namespace RecrownedGTK.Tools.TextureAtlas
 {
 
@@ -34,7 +33,7 @@ namespace RecrownedGTK.Tools.TextureAtlas
         /// <param name="rootDirectoryPath">Path to textures.</param>
         /// <param name="powLimit">Power of two limit for auto expanding texture. Default is 12 which is a 4096x4096 texture.</param>
         /// <param name="startingPower">What power to start at and build up from. Default is 8 which is a 256x256 texture.</param>
-        internal TexturePacker(string rootDirectoryPath, int powLimit = 12, int startingPower = 8)
+        internal TexturePacker(IUserOutput userOutput, string rootDirectoryPath, int powLimit = 12, int startingPower = 8)
         {
             this.powLimit = powLimit;
             string[] paths;
@@ -54,7 +53,7 @@ namespace RecrownedGTK.Tools.TextureAtlas
                 SupportedExtensions extension;
                 if (Enum.TryParse(Path.GetExtension(paths[pathID]).ToLower().Substring(1), out extension))
                 {
-                    ConsoleUtilities.WriteWrappedLine("Reading texture data for: " + paths[pathID]);
+                    userOutput.WrappedOutput("Reading texture data for: " + paths[pathID]);
                     ImageHandler image = new ImageHandler(paths[pathID]);
                     imageHandlers.Add(image);
                     minAreaRequired += image.Area;
@@ -66,7 +65,7 @@ namespace RecrownedGTK.Tools.TextureAtlas
                 else if (Path.GetExtension(paths[pathID]).ToLower() == ".9p")
                 {
                     if (ninePatchDictionary == null) ninePatchDictionary = new Dictionary<string, NinePatchInfo>();
-                    ConsoleUtilities.WriteWrappedLine("Reading ninepatch data for: " + paths[pathID]);
+                    userOutput.WrappedOutput("Reading ninepatch data for: " + paths[pathID]);
                     string serialized = File.ReadAllText(paths[pathID]);
                     NinePatchInfo npData = JsonConvert.DeserializeObject<NinePatchInfo>(serialized);
                     ninePatchDictionary.Add(npData.name, npData);

RecrownedGTK.Tools/TextureAtlasTools/TexturePackerCommand.cs

@@ -23,7 +23,7 @@ namespace RecrownedGTK.Tools.TextureAtlasTools
             };
         }
 
-        public override void Run(string[] arguments)
+        public override void Run(IUserInput userInput, IUserOutput userOutput, string[] arguments)
         {
 
             TexturePacker texturePacker = null;
@@ -36,29 +36,29 @@ namespace RecrownedGTK.Tools.TextureAtlasTools
             if (HasArgument("-interactive", arguments))
             {
                 string input;
-                ConsoleUtilities.WriteWrappedLine("Texture packer interactive mode triggered. Type \"q\" at any time to exit.");
+                userOutput.WrappedOutput("Texture packer interactive mode triggered. Type \"q\" at any time to exit.");
-                ConsoleUtilities.WriteWrappedLine("Please enter path of folder containing the textures to be packed.");
+                userOutput.WrappedOutput("Please enter path of folder containing the textures to be packed.");
-                input = Console.ReadLine();
+                input = userInput.GetInput();
                 if (input == "q") return;
                 path = input.Replace("\"", "");
 
-                ConsoleUtilities.WriteWrappedLine("Please enter output path of file name.");
+                userOutput.WrappedOutput("Please enter output path of file name.");
-                input = Console.ReadLine();
+                input = userInput.GetInput();
                 if (input == "q") return;
                 output = input.Replace("\"", "");
 
                 do
                 {
-                    ConsoleUtilities.WriteWrappedLine("Please enter a valid starting power of two for the lengths of the resulting texture atlas. Leave blank for default of " + sp + ".");
+                    userOutput.WrappedOutput("Please enter a valid starting power of two for the lengths of the resulting texture atlas. Leave blank for default of " + sp + ".");
-                    input = Console.ReadLine();
+                    input = userInput.GetInput();
                     if (input == "q") return;
                     if (input.Length == 0) break;
                 } while (!int.TryParse(input, out sp));
 
                 do
                 {
-                    ConsoleUtilities.WriteWrappedLine("Please enter a valid maximum power by two of the lengths of the resulting texture atlas. Leave blank for default of " + mp + ".");
+                    userOutput.WrappedOutput("Please enter a valid maximum power by two of the lengths of the resulting texture atlas. Leave blank for default of " + mp + ".");
-                    input = Console.ReadLine();
+                    input = userInput.GetInput();
                     if (input == "q") return;
                     if (input.Length == 0) break;
                 } while (!int.TryParse(input, out mp));
@@ -83,8 +83,8 @@ namespace RecrownedGTK.Tools.TextureAtlasTools
                 if (HasArgument("-dau", arguments)) dau = true;
             }
 
-            texturePacker = new TexturePacker(path, mp, sp);
+            texturePacker = new TexturePacker(userOutput, path, mp, sp);
-            ConsoleUtilities.WriteWrappedLine("Calculated minimum texture size: " + texturePacker.TextureLength + "x" + texturePacker.TextureLength + " with a total of " + texturePacker.TexturesFound + " textures.");
+            userOutput.WrappedOutput("Calculated minimum texture size: " + texturePacker.TextureLength + "x" + texturePacker.TextureLength + " with a total of " + texturePacker.TexturesFound + " textures.");
 
             try
             {
@@ -112,7 +112,7 @@ namespace RecrownedGTK.Tools.TextureAtlasTools
                 }
             }
             texturePacker.Save(Path.GetDirectoryName(output), Path.GetFileName(output));
-            Console.WriteLine("Complete. Final texture size: " + texturePacker.TextureLength + "x" + texturePacker.TextureLength + ".");
+            userOutput.Output("Complete. Final texture size: " + texturePacker.TextureLength + "x" + texturePacker.TextureLength + ".");
         }
     }
 }