refactor commands around to be in a separate ns

.editorconfig

@@ -9,7 +9,7 @@ indent_style = space
 [*.{cs,csx,vb,vbx}] 
 indent_size = 4 
 insert_final_newline = true 
-charset = utf-8-bom 
+charset = utf-8
 ############################### 
 # .NET Coding Conventions     # 
 ############################### 

src/ConsoleBuffer/Buffer.cs

@@ -92,49 +92,49 @@ private void ExecuteParserCommand()
         {
             switch (this.parser.Command)
             {
-            case ControlCharacterCommand ctrl:
+            case Commands.ControlCharacter ctrl:
                 this.HandleControlCharacter(ctrl.Code);
                 break;
-            case OSCommand osCommand:
-                if (osCommand.Command == OSCommand.Type.SetTitle)
+            case Commands.OS osCommand:
+                if (osCommand.Command == Commands.OS.Type.SetTitle)
                 {
                     this.Title = osCommand.Title;
                     this.OnPropertyChanged("Title");
                 }
                 break;
-            case UnsupportedCommand unsupported:
+            case Commands.Unsupported unsupported:
                 break;
             default:
                 throw new InvalidOperationException("Unknown command type passed.");
             }
         }
 
-        private void HandleControlCharacter(ControlCharacterCommand.ControlCode code)
+        private void HandleControlCharacter(Commands.ControlCharacter.ControlCode code)
         {
             switch (code)
             {
-            case ControlCharacterCommand.ControlCode.NUL:
+            case Commands.ControlCharacter.ControlCode.NUL:
                 // XXX: do we want to print these in some magic way? it seems like most terminals just discard these characters when received.
                 break;
-            case ControlCharacterCommand.ControlCode.BEL:
+            case Commands.ControlCharacter.ControlCode.BEL:
                 // XXX: need to raise a beep event.
                 break;
-            case ControlCharacterCommand.ControlCode.BS:
+            case Commands.ControlCharacter.ControlCode.BS:
                 this.cursorX = (short)Math.Max(0, this.cursorX - 1);
                 break;
-            case ControlCharacterCommand.ControlCode.CR:
+            case Commands.ControlCharacter.ControlCode.CR:
                 this.cursorX = 0;
                 break;
-            case ControlCharacterCommand.ControlCode.FF: // NB: could clear screen with this if we were so inclined. apparently xterm treats this as LF though, let's emulate.
-            case ControlCharacterCommand.ControlCode.LF:
+            case Commands.ControlCharacter.ControlCode.FF: // NB: could clear screen with this if we were so inclined. apparently xterm treats this as LF though, let's emulate.
+            case Commands.ControlCharacter.ControlCode.LF:
                 if (this.currentLine == this.lines.Size - 1)
                 {
                     this.lines.PushBack(new Line());
                 }
 
                 this.cursorY = (short)Math.Min(this.Height - 1, this.cursorY + 1);
                 break;
-            case ControlCharacterCommand.ControlCode.TAB:
+            case Commands.ControlCharacter.ControlCode.TAB:
                 // XXX: we don't handle commands to set tab stops yet but I guess need to do so at some point!
                 this.cursorX = (short)Math.Max(this.Width - 1, (this.cursorX + 8 - (this.cursorX % 8)));
                 break;

src/ConsoleBuffer/Commands/BaseCommand.cs → src/ConsoleBuffer/Commands/Base.cs

@@ -1,18 +1,18 @@
-namespace ConsoleBuffer
+namespace ConsoleBuffer.Commands
 {
-    public abstract class BaseCommand
+    public abstract class Base
     {
-        internal BaseCommand(string bufferData)
+        internal Base(string bufferData)
         {
             this.Parse(bufferData);
         }
 
         protected abstract void Parse(string bufferData);
     }
 
-    public sealed class UnsupportedCommand : BaseCommand
+    public sealed class Unsupported : Base
     {
-        internal UnsupportedCommand(string buffer) : base(null)
+        internal Unsupported(string buffer) : base(null)
         {
             Logger.Verbose($"Unsupported command: {buffer}");
         }

src/ConsoleBuffer/Commands/ControlCharacterCommand.cs → src/ConsoleBuffer/Commands/ControlCharacter.cs

@@ -1,6 +1,6 @@
-namespace ConsoleBuffer
+namespace ConsoleBuffer.Commands
 {
-    public sealed class ControlCharacterCommand : BaseCommand
+    public sealed class ControlCharacter : Base
     {
         public enum ControlCode
         {
@@ -36,11 +36,11 @@ public enum ControlCode
 
         public readonly ControlCode Code;
 
-        public ControlCharacterCommand(ControlCode code) : base(null)
+        public ControlCharacter(ControlCode code) : base(null)
         {
             this.Code = code;
         }
 
         protected override void Parse(string bufferData) { }
     }
-}
+}

src/ConsoleBuffer/Commands/ControlSequenceCommand.cs → src/ConsoleBuffer/Commands/ControlSequence.cs

@@ -1,26 +1,26 @@
-using System;
-using System.Collections.Generic;
-
-namespace ConsoleBuffer
+namespace ConsoleBuffer.Commands
 {
-    public abstract class ControlSequenceCommand : BaseCommand
+    using System;
+    using System.Collections.Generic;
+
+    public abstract class ControlSequence : Base
     {
-        public static BaseCommand Create(char command, string bufferData)
+        public static Base Create(char command, string bufferData)
         {
             switch (command)
             {
             case 'J':
-                var cmd = new EraseInDisplayCommand(bufferData);
+                var cmd = new EraseInDisplay(bufferData);
                 if (!cmd.IsExtended) // currently no support for selective erase in display
                     return cmd;
                 break;
             }
-            return new UnsupportedCommand($"^[[{bufferData}{command}");
+            return new Unsupported($"^[[{bufferData}{command}");
         }
 
         protected bool IsExtended { get; private set; }
         protected IList<string> Parameters { get; private set; }
-        protected ControlSequenceCommand(string bufferData) : base(bufferData) { }
+        protected ControlSequence(string bufferData) : base(bufferData) { }
         protected override void Parse(string bufferData)
         {
             var startIndex = 0;

src/ConsoleBuffer/Commands/EraseInDisplay.cs

@@ -1,7 +1,7 @@
-namespace ConsoleBuffer
+namespace ConsoleBuffer.Commands
 {
-    public sealed class EraseInDisplayCommand : ControlSequenceCommand
+    public sealed class EraseInDisplay : ControlSequence
     {
-        public EraseInDisplayCommand(string bufferData) : base(bufferData) { }
+        public EraseInDisplay(string bufferData) : base(bufferData) { }
     }
 }

src/ConsoleBuffer/Commands/OSCommand.cs → src/ConsoleBuffer/Commands/OS.cs

@@ -1,6 +1,6 @@
-namespace ConsoleBuffer
+namespace ConsoleBuffer.Commands
 {
-    public sealed class OSCommand : BaseCommand
+    public sealed class OS : Base
     {
         public enum Type
         {
@@ -11,7 +11,7 @@ public enum Type
         public Type Command { get; private set; }
         public string Title { get; private set; }
 
-        public OSCommand(string bufferData) : base(bufferData) { }
+        public OS(string bufferData) : base(bufferData) { }
 
         protected override void Parse(string bufferData)
         {
@@ -34,4 +34,4 @@ protected override void Parse(string bufferData)
             }
         }
     }
-}
+}

src/ConsoleBuffer/SequenceParser.cs

@@ -75,7 +75,7 @@ enum State
         /// <summary>
         /// The current command (may be null if none).
         /// </summary>
-        public BaseCommand Command { get; private set; }
+        public Commands.Base Command { get; private set; }
 
         public SequenceParser() { }
 
@@ -111,22 +111,22 @@ private ParserAppendResult AppendNone(int character)
             switch (character)
             {
             case '\0':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.NUL));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.NUL));
             case '\a':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.BEL));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.BEL));
             case '\b':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.BS));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.BS));
             case '\f':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.FF));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.FF));
             case '\n':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.LF));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.LF));
             case '\r':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.CR));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.CR));
             case '\t':
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.TAB));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.TAB));
             case '\v':
                 // NB: old timey tech sure was funny. vertical tabs. ha ha ha.
-                return this.CompleteCommand(new ControlCharacterCommand(ControlCharacterCommand.ControlCode.LF));
+                return this.CompleteCommand(new Commands.ControlCharacter(Commands.ControlCharacter.ControlCode.LF));
             case 0x1b: // ^[ / escape
                 this.state = State.Basic;
                 return ParserAppendResult.Pending;
@@ -152,7 +152,7 @@ private ParserAppendResult AppendBasic(int character)
                 this.state = State.ApplicationProgramCommand;
                 return ParserAppendResult.Pending;
             default:
-                return this.CompleteCommand(new UnsupportedCommand($"^[{(char)character}"), ParserAppendResult.Invalid);
+                return this.CompleteCommand(new Commands.Unsupported($"^[{(char)character}"), ParserAppendResult.Invalid);
             }
         }
 
@@ -167,8 +167,7 @@ private ParserAppendResult AppendControlSequence(int character)
                 return ParserAppendResult.Pending;
             }
 
-            return this.CompleteCommand(ControlSequenceCommand.Create((char)character, this.buffer.ToString()));
-            return this.CompleteCommand(new UnsupportedCommand($"^[[{this.buffer.ToString()}{(char)character}"));
+            return this.CompleteCommand(Commands.ControlSequence.Create((char)character, this.buffer.ToString()));
         }
 
         private ParserAppendResult AppendOSCommand(int character)
@@ -177,7 +176,7 @@ private ParserAppendResult AppendOSCommand(int character)
             {
             case '\a':
             case '\0':
-                return this.CompleteCommand(new OSCommand(this.buffer.ToString()));
+                return this.CompleteCommand(new Commands.OS(this.buffer.ToString()));
             default:
                 this.buffer.Append((char)character); // XXX: nukes astral plane support for giganto unicode characters. care later.
                 return ParserAppendResult.Pending;
@@ -189,13 +188,13 @@ private ParserAppendResult AppendUntilST(int character)
             switch (character)
             {
             case '\0':
-                return this.CompleteCommand(new UnsupportedCommand("(ASC or PM goo)"));
+                return this.CompleteCommand(new Commands.Unsupported("(ASC or PM goo)"));
             default:
                 return ParserAppendResult.Pending;
             }
         }
 
-        private ParserAppendResult CompleteCommand(BaseCommand command, ParserAppendResult result = ParserAppendResult.Complete)
+        private ParserAppendResult CompleteCommand(Commands.Base command, ParserAppendResult result = ParserAppendResult.Complete)
         {
             this.Command = command ?? throw new ArgumentNullException(nameof(command));
             this.state = State.Reset;

test/ConsoleBufferTests/SequenceParserTests.cs

@@ -17,20 +17,20 @@ public void Basic()
         }
 
         [TestMethod]
-        [DataRow('\0', ControlCharacterCommand.ControlCode.NUL)]
-        [DataRow('\a', ControlCharacterCommand.ControlCode.BEL)]
-        [DataRow('\b', ControlCharacterCommand.ControlCode.BS)]
-        [DataRow('\f', ControlCharacterCommand.ControlCode.FF)]
-        [DataRow('\n', ControlCharacterCommand.ControlCode.LF)]
-        [DataRow('\r', ControlCharacterCommand.ControlCode.CR)]
-        [DataRow('\t', ControlCharacterCommand.ControlCode.TAB)]
-        [DataRow('\v', ControlCharacterCommand.ControlCode.LF)] // lmao vertical tabs
-        public void ControlCharacters(char c, ControlCharacterCommand.ControlCode code)
+        [DataRow('\0', ConsoleBuffer.Commands.ControlCharacter.ControlCode.NUL)]
+        [DataRow('\a', ConsoleBuffer.Commands.ControlCharacter.ControlCode.BEL)]
+        [DataRow('\b', ConsoleBuffer.Commands.ControlCharacter.ControlCode.BS)]
+        [DataRow('\f', ConsoleBuffer.Commands.ControlCharacter.ControlCode.FF)]
+        [DataRow('\n', ConsoleBuffer.Commands.ControlCharacter.ControlCode.LF)]
+        [DataRow('\r', ConsoleBuffer.Commands.ControlCharacter.ControlCode.CR)]
+        [DataRow('\t', ConsoleBuffer.Commands.ControlCharacter.ControlCode.TAB)]
+        [DataRow('\v', ConsoleBuffer.Commands.ControlCharacter.ControlCode.LF)] // lmao vertical tabs
+        public void ControlCharacters(char c, ConsoleBuffer.Commands.ControlCharacter.ControlCode code)
         {
             var parser = new SequenceParser();
             Assert.AreEqual(ParserAppendResult.Complete, parser.Append(c));
-            Assert.IsInstanceOfType(parser.Command, typeof(ControlCharacterCommand));
-            Assert.AreEqual(code, (parser.Command as ControlCharacterCommand).Code);
+            Assert.IsInstanceOfType(parser.Command, typeof(ConsoleBuffer.Commands.ControlCharacter));
+            Assert.AreEqual(code, (parser.Command as ConsoleBuffer.Commands.ControlCharacter).Code);
         }
 
         [TestMethod]
@@ -46,7 +46,7 @@ public void UnsupportedAncientStuff(char c)
                 Assert.AreEqual(ParserAppendResult.Pending, parser.Append(ancientCommand[i]));
             }
             Assert.AreEqual(ParserAppendResult.Complete, parser.Append(ancientCommand[ancientCommand.Length - 1]));
-            Assert.IsInstanceOfType(parser.Command, typeof(UnsupportedCommand));
+            Assert.IsInstanceOfType(parser.Command, typeof(ConsoleBuffer.Commands.Unsupported));
         }
 
         [TestMethod]
@@ -61,9 +61,9 @@ public void OSCommands()
                 Assert.AreEqual(ParserAppendResult.Pending, parser.Append(command[i]));
             }
             Assert.AreEqual(ParserAppendResult.Complete, parser.Append(command[command.Length - 1]));
-            Assert.IsInstanceOfType(parser.Command, typeof(OSCommand));
+            Assert.IsInstanceOfType(parser.Command, typeof(ConsoleBuffer.Commands.OS));
 
-            var osCmd = parser.Command as OSCommand;
+            var osCmd = parser.Command as ConsoleBuffer.Commands.OS;
             Assert.AreEqual(title, osCmd.Title);
         }
     }