[orion-based] [WIP] Commands Implementation

.editorconfig

@@ -66,12 +66,13 @@ csharp_style_var_for_built_in_types=true:silent
 csharp_style_var_when_type_is_apparent=true:silent
 csharp_style_var_elsewhere=true:silent
 # Expression-bodied members 
-csharp_style_expression_bodied_methods=false:silent
+csharp_style_expression_bodied_methods=true:silent
 csharp_style_expression_bodied_constructors=false:silent
-csharp_style_expression_bodied_operators=false:silent
+csharp_style_expression_bodied_operators=true:silent
 csharp_style_expression_bodied_properties=true:silent
 csharp_style_expression_bodied_indexers=true:silent
 csharp_style_expression_bodied_accessors=true:silent
+csharp_style_expression_bodied_local_functions = true:silent
 # Pattern matching preferences 
 csharp_style_pattern_matching_over_is_with_cast_check=true:suggestion
 csharp_style_pattern_matching_over_as_with_null_check=true:suggestion

src/TShock/Commands/CommandHandlerAttribute.cs

@@ -16,37 +16,98 @@
 // along with TShock.  If not, see <https://www.gnu.org/licenses/>.
 
 using System;
-using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using JetBrains.Annotations;
+using TShock.Utils;
 
 namespace TShock.Commands {
     /// <summary>
-    /// An attribute that can be applied to a method to indicate that it is a command handler. This can be applied to
-    /// a method mutiple times to provide aliasing.
+    /// Specifies that a method is a command handler. This controls many aspects of the command, and can be applied
+    /// multiple times to provide aliasing.
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    [MeansImplicitUse]
     public sealed class CommandHandlerAttribute : Attribute {
+        private readonly string _qualifiedName;
+
+        private string? _helpText;
+        private string? _usageText;
+        private Type? _resourceType;
+
+        /// <summary>
+        /// Gets the qualified name. This includes the namespace: e.g., <c>tshock:kick</c>.
+        /// </summary>
+        /// <value>The qualified name.</value>
+        public string QualifiedName => GetResourceStringMaybe(_qualifiedName);
+
+        /// <summary>
+        /// Gets or sets the help text. This will show up in the /help command. If <see langword="null"/>, then no help
+        /// text exists. 
+        /// </summary>
+        /// <value>The help text.</value>
+        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
+        [DisallowNull]
+        public string? HelpText {
+            get => GetResourceStringMaybe(_helpText);
+            set => _helpText = value ?? throw new ArgumentNullException(nameof(value));
+        }
+
         /// <summary>
-        /// Gets the command's name. This includes the command's namespace: e.g., <c>"tshock:kick"</c>.
+        /// Gets or sets the usage text. This will show up in the /help command and when invalid syntax is used. If
+        /// <see langword="null"/>, then no usage text exists.
         /// </summary>
-        public string CommandName { get; }
+        /// <value>The usage text.</value>
+        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
+        [DisallowNull]
+        public string? UsageText {
+            get => GetResourceStringMaybe(_usageText);
+            set => _usageText = value ?? throw new ArgumentNullException(nameof(value));
+        }
+
+        /// <summary>
+        /// Gets or sets the resource type to load localizable strings from. If <see langword="null"/>, then no
+        /// localization will occur.
+        /// </summary>
+        /// <value>The resource type to load localizable strings from.</value>
+        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
+        [DisallowNull]
+        public Type? ResourceType {
+            get => _resourceType;
+            set => _resourceType = value ?? throw new ArgumentNullException(nameof(value));
+        }
 
         /// <summary>
-        /// Gets the command's sub-names.
+        /// Gets or sets a value indicating whether the command should be logged.
         /// </summary>
-        public IEnumerable<string> CommandSubNames { get; }
+        /// <value><see langword="true"/> if the command should be logged; otherwise, <see langword="false"/>.</value>
+        /// <remarks>This property's value is useful for hiding, e.g., authentication commands.</remarks>
+        public bool ShouldBeLogged { get; set; } = true;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="CommandHandlerAttribute"/> class with the given command name
-        /// and sub-names.
+        /// Initializes a new instance of the <see cref="CommandHandlerAttribute"/> class with the specified qualified
+        /// name.
         /// </summary>
-        /// <param name="commandName">The command name.</param>
-        /// <param name="commandSubNames">The command sub-names.</param>
+        /// <param name="qualifiedName">
+        /// The qualified name. This includes the namespace: e.g., <c>tshock:kick</c>.
+        /// </param>
         /// <exception cref="ArgumentNullException">
-        /// <paramref name="commandName"/> or <paramref name="commandSubNames"/> are <c>null</c>.
+        /// <paramref name="qualifiedName"/> is <see langword="null"/>.
         /// </exception>
-        public CommandHandlerAttribute(string commandName, params string[] commandSubNames) {
-            CommandName = commandName ?? throw new ArgumentNullException(nameof(commandName));
-            CommandSubNames = commandSubNames ?? throw new ArgumentNullException(nameof(commandSubNames));
+        public CommandHandlerAttribute(string qualifiedName) {
+            if (qualifiedName is null) {
+                throw new ArgumentNullException(nameof(qualifiedName));
+            }
+
+            _qualifiedName = qualifiedName;
+        }
+
+        [return: NotNullIfNotNull("str")]
+        private string? GetResourceStringMaybe(string? str) {
+            if (str is null) {
+                return null;
+            }
+
+            return _resourceType != null ? ResourceHelper.LoadResource<string>(_resourceType, str) : str;
         }
     }
 }

src/TShock/Commands/ConsoleCommandSender.cs

@@ -0,0 +1,107 @@
+// Copyright (c) 2019 Pryaxis & TShock Contributors
+// 
+// This file is part of TShock.
+// 
+// TShock is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// TShock is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with TShock.  If not, see <https://www.gnu.org/licenses/>.
+
+using System;
+using System.Globalization;
+using System.Text;
+using Destructurama;
+using JetBrains.Annotations;
+using Microsoft.Xna.Framework;
+using Orion.Players;
+using Serilog;
+using Serilog.Events;
+using Serilog.Sinks.SystemConsole.Themes;
+
+namespace TShock.Commands {
+    /// <summary>
+    /// Represents a console-based command sender.
+    /// </summary>
+    public sealed class ConsoleCommandSender : ICommandSender {
+#if DEBUG
+        private const LogEventLevel LogLevel = LogEventLevel.Verbose;
+#else
+        private const LogEventLevel LogLevel = LogEventLevel.Error;
+#endif
+
+        /// <summary>
+        /// Gets the console-based command sender.
+        /// </summary>
+        /// <value>The console-based command sender.</value>
+        public static ConsoleCommandSender Instance { get; } = new ConsoleCommandSender();
+
+        /// <inheritdoc/>
+        public string Name => "Console";
+
+        /// <inheritdoc/>
+        public ILogger Log { get; }
+
+        /// <inheritdoc/>
+        public IPlayer? Player => null;
+
+        [Pure]
+        private static string GetColorString(Color color) => $"\x1b[38;2;{color.R};{color.G};{color.B}m";
+
+        private ConsoleCommandSender() {
+            Log = new LoggerConfiguration()
+                .Destructure.UsingAttributes()
+                .WriteTo.Console(
+                    outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:l}{NewLine}{Exception}",
+                    theme: AnsiConsoleTheme.Code)
+                .MinimumLevel.Is(LogLevel)
+                .CreateLogger();
+        }
+
+        /// <inheritdoc/>
+        public void SendMessage(string message) => SendMessageImpl(message, string.Empty);
+
+        /// <inheritdoc/>
+        public void SendMessage(string message, Color color) => SendMessageImpl(message, GetColorString(color));
+
+        private static void SendMessageImpl(ReadOnlySpan<char> message, string colorString) {
+            var output = new StringBuilder(message.Length);
+            while (true) {
+                output.Append(colorString);
+                var leftBracket = message.IndexOf('[');
+                var rightBracket = leftBracket + 1 + message[(leftBracket + 1)..].IndexOf(']');
+                if (leftBracket < 0 || rightBracket < 0) {
+                    break;
+                }
+
+                output.Append(message[..leftBracket]);
+                var inside = message[(leftBracket + 1)..rightBracket];
+                message = message[(rightBracket + 1)..];
+                var colon = inside.IndexOf(':');
+                var isValidColorTag = inside.StartsWith("c/", StringComparison.OrdinalIgnoreCase) && colon > 2;
+                if (!isValidColorTag) {
+                    output.Append('[').Append(inside).Append(']');
+                    continue;
+                }
+
+                if (int.TryParse(inside[2..colon], NumberStyles.AllowHexSpecifier,
+                        CultureInfo.InvariantCulture, out var numberColor)) {
+                    var tagColor = new Color((numberColor >> 16) & 255, (numberColor >> 8) & 255, numberColor & 255);
+                    output.Append(GetColorString(tagColor));
+                }
+
+                output.Append(inside[(colon + 1)..]);
+            }
+
+            output.Append(message).Append("\x1b[0m");
+            Console.WriteLine(output);
+        }
+    }
+}

src/TShock/Commands/Exceptions/CommandExecuteException.cs

@@ -0,0 +1,46 @@
+// Copyright (c) 2019 Pryaxis & TShock Contributors
+// 
+// This file is part of TShock.
+// 
+// TShock is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// TShock is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with TShock.  If not, see <https://www.gnu.org/licenses/>.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace TShock.Commands.Exceptions {
+    /// <summary>
+    /// The exception thrown when a command could not be executed.
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    public class CommandExecuteException : Exception {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandExecuteException"/> class.
+        /// </summary>
+        public CommandExecuteException() { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandExecuteException"/> class with the specified message.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        public CommandExecuteException(string message) : base(message) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandExecuteException"/> class with the specified message
+        /// and inner exception.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="innerException">The inner exception.</param>
+        public CommandExecuteException(string message, Exception innerException) : base(message, innerException) { }
+    }
+}

src/TShock/Commands/Exceptions/CommandNotFoundException.cs

@@ -0,0 +1,46 @@
+// Copyright (c) 2019 Pryaxis & TShock Contributors
+// 
+// This file is part of TShock.
+// 
+// TShock is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// TShock is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with TShock.  If not, see <https://www.gnu.org/licenses/>.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace TShock.Commands.Exceptions {
+    /// <summary>
+    /// The exception thrown when a command could not be found.
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    public class CommandNotFoundException : Exception {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandNotFoundException"/> class.
+        /// </summary>
+        public CommandNotFoundException() { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandNotFoundException"/> class with the specified message.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        public CommandNotFoundException(string message) : base(message) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandNotFoundException"/> class with the specified message
+        /// and inner exception.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="innerException">The inner exception.</param>
+        public CommandNotFoundException(string message, Exception innerException) : base(message, innerException) { }
+    }
+}

src/TShock/Commands/Exceptions/CommandParseException.cs

@@ -0,0 +1,46 @@
+// Copyright (c) 2019 Pryaxis & TShock Contributors
+// 
+// This file is part of TShock.
+// 
+// TShock is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// TShock is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with TShock.  If not, see <https://www.gnu.org/licenses/>.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace TShock.Commands.Exceptions {
+    /// <summary>
+    /// The exception thrown when a command input cannot be parsed.
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    public class CommandParseException : Exception {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandParseException"/> class.
+        /// </summary>
+        public CommandParseException() { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandParseException"/> class with the specified message.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        public CommandParseException(string message) : base(message) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandParseException"/> class with the specified message and
+        /// inner exception.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="innerException">The inner exception.</param>
+        public CommandParseException(string message, Exception innerException) : base(message, innerException) { }
+    }
+}