Add global usings (#668)

* Use global usings

* Fix namespace declarations for test projects

test/Spectre.Console.Tests/Data/Commands/AnimalCommand.cs

@@ -1,49 +1,45 @@
-using System;
-using System.Linq;
-using Spectre.Console.Cli;
 using SystemConsole = System.Console;
 
-namespace Spectre.Console.Tests.Data
+namespace Spectre.Console.Tests.Data;
+
+public abstract class AnimalCommand<TSettings> : Command<TSettings>
+    where TSettings : CommandSettings
 {
-    public abstract class AnimalCommand<TSettings> : Command<TSettings>
-        where TSettings : CommandSettings
+    protected void DumpSettings(CommandContext context, TSettings settings)
     {
-        protected void DumpSettings(CommandContext context, TSettings settings)
+        if (context == null)
         {
-            if (context == null)
-            {
-                throw new ArgumentNullException(nameof(context));
-            }
-
-            if (settings == null)
-            {
-                throw new ArgumentNullException(nameof(settings));
-            }
-
-            var properties = settings.GetType().GetProperties();
-            foreach (var group in properties.GroupBy(x => x.DeclaringType).Reverse())
-            {
-                SystemConsole.WriteLine();
-                SystemConsole.ForegroundColor = ConsoleColor.Yellow;
-                SystemConsole.WriteLine(group.Key.FullName);
-                SystemConsole.ResetColor();
-
-                foreach (var property in group)
-                {
-                    SystemConsole.WriteLine($"  {property.Name} = {property.GetValue(settings)}");
-                }
-            }
-
-            if (context.Remaining.Raw.Count > 0)
-            {
-                SystemConsole.WriteLine();
-                SystemConsole.ForegroundColor = ConsoleColor.Yellow;
-                SystemConsole.WriteLine("Remaining:");
-                SystemConsole.ResetColor();
-                SystemConsole.WriteLine(string.Join(", ", context.Remaining));
-            }
-
-            SystemConsole.WriteLine();
+            throw new ArgumentNullException(nameof(context));
         }
+
+        if (settings == null)
+        {
+            throw new ArgumentNullException(nameof(settings));
+        }
+
+        var properties = settings.GetType().GetProperties();
+        foreach (var group in properties.GroupBy(x => x.DeclaringType).Reverse())
+        {
+            SystemConsole.WriteLine();
+            SystemConsole.ForegroundColor = ConsoleColor.Yellow;
+            SystemConsole.WriteLine(group.Key.FullName);
+            SystemConsole.ResetColor();
+
+            foreach (var property in group)
+            {
+                SystemConsole.WriteLine($"  {property.Name} = {property.GetValue(settings)}");
+            }
+        }
+
+        if (context.Remaining.Raw.Count > 0)
+        {
+            SystemConsole.WriteLine();
+            SystemConsole.ForegroundColor = ConsoleColor.Yellow;
+            SystemConsole.WriteLine("Remaining:");
+            SystemConsole.ResetColor();
+            SystemConsole.WriteLine(string.Join(", ", context.Remaining));
+        }
+
+        SystemConsole.WriteLine();
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/CatCommand.cs

@@ -1,13 +1,10 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class CatCommand : AnimalCommand<CatSettings>
 {
-    public class CatCommand : AnimalCommand<CatSettings>
+    public override int Execute(CommandContext context, CatSettings settings)
     {
-        public override int Execute(CommandContext context, CatSettings settings)
-        {
-            DumpSettings(context, settings);
-            return 0;
-        }
+        DumpSettings(context, settings);
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/DogCommand.cs

@@ -1,36 +1,31 @@
-using System.ComponentModel;
-using System.Linq;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+[Description("The dog command.")]
+public class DogCommand : AnimalCommand<DogSettings>
 {
-    [Description("The dog command.")]
-    public class DogCommand : AnimalCommand<DogSettings>
+    public override ValidationResult Validate(CommandContext context, DogSettings settings)
     {
-        public override ValidationResult Validate(CommandContext context, DogSettings settings)
+        if (context is null)
         {
-            if (context is null)
-            {
-                throw new System.ArgumentNullException(nameof(context));
-            }
-
-            if (settings is null)
-            {
-                throw new System.ArgumentNullException(nameof(settings));
-            }
-
-            if (settings.Age > 100 && !context.Remaining.Raw.Contains("zombie"))
-            {
-                return ValidationResult.Error("Dog is too old...");
-            }
-
-            return base.Validate(context, settings);
+            throw new System.ArgumentNullException(nameof(context));
         }
 
-        public override int Execute(CommandContext context, DogSettings settings)
+        if (settings is null)
         {
-            DumpSettings(context, settings);
-            return 0;
+            throw new System.ArgumentNullException(nameof(settings));
         }
+
+        if (settings.Age > 100 && !context.Remaining.Raw.Contains("zombie"))
+        {
+            return ValidationResult.Error("Dog is too old...");
+        }
+
+        return base.Validate(context, settings);
     }
-}
+
+    public override int Execute(CommandContext context, DogSettings settings)
+    {
+        DumpSettings(context, settings);
+        return 0;
+    }
+}

test/Spectre.Console.Tests/Data/Commands/DumpRemainingCommand.cs

@@ -1,39 +1,34 @@
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class DumpRemainingCommand : Command<EmptyCommandSettings>
 {
-    public sealed class DumpRemainingCommand : Command<EmptyCommandSettings>
+    private readonly IAnsiConsole _console;
+
+    public DumpRemainingCommand(IAnsiConsole console)
     {
-        private readonly IAnsiConsole _console;
-
-        public DumpRemainingCommand(IAnsiConsole console)
-        {
-            _console = console;
-        }
-
-        public override int Execute([NotNull] CommandContext context, [NotNull] EmptyCommandSettings settings)
-        {
-            if (context.Remaining.Raw.Count > 0)
-            {
-                _console.WriteLine("# Raw");
-                foreach (var item in context.Remaining.Raw)
-                {
-                    _console.WriteLine(item);
-                }
-            }
-
-            if (context.Remaining.Parsed.Count > 0)
-            {
-                _console.WriteLine("# Parsed");
-                foreach (var item in context.Remaining.Parsed)
-                {
-                    _console.WriteLine(string.Format("{0}={1}", item.Key, string.Join(",", item.Select(x => x))));
-                }
-            }
-
-            return 0;
-        }
+        _console = console;
     }
-}
+
+    public override int Execute([NotNull] CommandContext context, [NotNull] EmptyCommandSettings settings)
+    {
+        if (context.Remaining.Raw.Count > 0)
+        {
+            _console.WriteLine("# Raw");
+            foreach (var item in context.Remaining.Raw)
+            {
+                _console.WriteLine(item);
+            }
+        }
+
+        if (context.Remaining.Parsed.Count > 0)
+        {
+            _console.WriteLine("# Parsed");
+            foreach (var item in context.Remaining.Parsed)
+            {
+                _console.WriteLine(string.Format("{0}={1}", item.Key, string.Join(",", item.Select(x => x))));
+            }
+        }
+
+        return 0;
+    }
+}

test/Spectre.Console.Tests/Data/Commands/EmptyCommand.cs

@@ -1,12 +1,9 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class EmptyCommand : Command<EmptyCommandSettings>
 {
-    public sealed class EmptyCommand : Command<EmptyCommandSettings>
+    public override int Execute(CommandContext context, EmptyCommandSettings settings)
     {
-        public override int Execute(CommandContext context, EmptyCommandSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/GenericCommand.cs

@@ -1,13 +1,10 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class GenericCommand<TSettings> : Command<TSettings>
+    where TSettings : CommandSettings
 {
-    public sealed class GenericCommand<TSettings> : Command<TSettings>
-        where TSettings : CommandSettings
+    public override int Execute(CommandContext context, TSettings settings)
     {
-        public override int Execute(CommandContext context, TSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/GiraffeCommand.cs

@@ -1,14 +1,10 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+[Description("The giraffe command.")]
+public sealed class GiraffeCommand : Command<GiraffeSettings>
 {
-    [Description("The giraffe command.")]
-    public sealed class GiraffeCommand : Command<GiraffeSettings>
+    public override int Execute(CommandContext context, GiraffeSettings settings)
     {
-        public override int Execute(CommandContext context, GiraffeSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/HiddenOptionsCommand.cs

@@ -1,12 +1,9 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class HiddenOptionsCommand : Command<HiddenOptionSettings>
 {
-    public sealed class HiddenOptionsCommand : Command<HiddenOptionSettings>
+    public override int Execute(CommandContext context, HiddenOptionSettings settings)
     {
-        public override int Execute(CommandContext context, HiddenOptionSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/HorseCommand.cs

@@ -1,15 +1,11 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+[Description("The horse command.")]
+public class HorseCommand : AnimalCommand<MammalSettings>
 {
-    [Description("The horse command.")]
-    public class HorseCommand : AnimalCommand<MammalSettings>
+    public override int Execute(CommandContext context, MammalSettings settings)
     {
-        public override int Execute(CommandContext context, MammalSettings settings)
-        {
-            DumpSettings(context, settings);
-            return 0;
-        }
+        DumpSettings(context, settings);
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/InvalidCommand.cs

@@ -1,12 +1,9 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class InvalidCommand : Command<InvalidSettings>
 {
-    public sealed class InvalidCommand : Command<InvalidSettings>
+    public override int Execute(CommandContext context, InvalidSettings settings)
     {
-        public override int Execute(CommandContext context, InvalidSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/LionCommand.cs

@@ -1,14 +1,10 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+[Description("The lion command.")]
+public class LionCommand : AnimalCommand<LionSettings>
 {
-    [Description("The lion command.")]
-    public class LionCommand : AnimalCommand<LionSettings>
+    public override int Execute(CommandContext context, LionSettings settings)
     {
-        public override int Execute(CommandContext context, LionSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/NoDescriptionCommand.cs

@@ -1,16 +1,12 @@
-using System.Diagnostics.CodeAnalysis;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class NoDescriptionCommand : Command<EmptyCommandSettings>
 {
-    public sealed class NoDescriptionCommand : Command<EmptyCommandSettings>
-    {
-        [CommandOption("-f|--foo <VALUE>")]
-        public int Foo { get; set; }
+    [CommandOption("-f|--foo <VALUE>")]
+    public int Foo { get; set; }
 
-        public override int Execute([NotNull] CommandContext context, [NotNull] EmptyCommandSettings settings)
-        {
-            return 0;
-        }
+    public override int Execute([NotNull] CommandContext context, [NotNull] EmptyCommandSettings settings)
+    {
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/OptionVectorCommand.cs

@@ -1,12 +1,9 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class OptionVectorCommand : Command<OptionVectorSettings>
 {
-    public class OptionVectorCommand : Command<OptionVectorSettings>
+    public override int Execute(CommandContext context, OptionVectorSettings settings)
     {
-        public override int Execute(CommandContext context, OptionVectorSettings settings)
-        {
-            return 0;
-        }
+        return 0;
     }
-}
+}

test/Spectre.Console.Tests/Data/Commands/ThrowingCommand.cs

@@ -1,17 +1,13 @@
-using System;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class ThrowingCommand : Command<ThrowingCommandSettings>
 {
-    public sealed class ThrowingCommand : Command<ThrowingCommandSettings>
+    public override int Execute(CommandContext context, ThrowingCommandSettings settings)
     {
-        public override int Execute(CommandContext context, ThrowingCommandSettings settings)
-        {
-            throw new InvalidOperationException("W00t?");
-        }
+        throw new InvalidOperationException("W00t?");
     }
+}
 
-    public sealed class ThrowingCommandSettings : CommandSettings
-    {
-    }
-}
+public sealed class ThrowingCommandSettings : CommandSettings
+{
+}

test/Spectre.Console.Tests/Data/Converters/CatAgilityConverter.cs

@@ -1,18 +1,14 @@
-using System.ComponentModel;
-using System.Globalization;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class CatAgilityConverter : TypeConverter
 {
-    public sealed class CatAgilityConverter : TypeConverter
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
     {
-        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        if (value is string stringValue)
         {
-            if (value is string stringValue)
-            {
-                return stringValue.Length;
-            }
-
-            return base.ConvertFrom(context, culture, value);
+            return stringValue.Length;
         }
+
+        return base.ConvertFrom(context, culture, value);
     }
-}
+}

test/Spectre.Console.Tests/Data/Converters/StringToIntegerConverter.cs

@@ -1,18 +1,14 @@
-using System.ComponentModel;
-using System.Globalization;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class StringToIntegerConverter : TypeConverter
 {
-    public sealed class StringToIntegerConverter : TypeConverter
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
     {
-        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        if (value is string stringValue)
         {
-            if (value is string stringValue)
-            {
-                return int.Parse(stringValue, CultureInfo.InvariantCulture);
-            }
-
-            return base.ConvertFrom(context, culture, value);
+            return int.Parse(stringValue, CultureInfo.InvariantCulture);
         }
+
+        return base.ConvertFrom(context, culture, value);
     }
-}
+}

test/Spectre.Console.Tests/Data/Exceptions.cs

@@ -1,35 +1,32 @@
-using System;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public static class TestExceptions
 {
-    public static class TestExceptions
+    public static bool MethodThatThrows(int? number) => throw new InvalidOperationException("Throwing!");
+
+    public static bool GenericMethodThatThrows<T0, T1, TRet>(int? number) => throw new InvalidOperationException("Throwing!");
+
+    public static void ThrowWithInnerException()
     {
-        public static bool MethodThatThrows(int? number) => throw new InvalidOperationException("Throwing!");
-
-        public static bool GenericMethodThatThrows<T0, T1, TRet>(int? number) => throw new InvalidOperationException("Throwing!");
-
-        public static void ThrowWithInnerException()
+        try
         {
-            try
-            {
-                MethodThatThrows(null);
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException("Something threw!", ex);
-            }
+            MethodThatThrows(null);
         }
-
-        public static void ThrowWithGenericInnerException()
+        catch (Exception ex)
         {
-            try
-            {
-                GenericMethodThatThrows<int, float, double>(null);
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException("Something threw!", ex);
-            }
+            throw new InvalidOperationException("Something threw!", ex);
         }
     }
-}
+
+    public static void ThrowWithGenericInnerException()
+    {
+        try
+        {
+            GenericMethodThatThrows<int, float, double>(null);
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException("Something threw!", ex);
+        }
+    }
+}

test/Spectre.Console.Tests/Data/Settings/AnimalSettings.cs

@@ -1,18 +1,14 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public abstract class AnimalSettings : CommandSettings
 {
-    public abstract class AnimalSettings : CommandSettings
-    {
-        [CommandOption("-a|--alive|--not-dead")]
-        [Description("Indicates whether or not the animal is alive.")]
-        public bool IsAlive { get; set; }
+    [CommandOption("-a|--alive|--not-dead")]
+    [Description("Indicates whether or not the animal is alive.")]
+    public bool IsAlive { get; set; }
 
-        [CommandArgument(1, "[LEGS]")]
-        [Description("The number of legs.")]
-        [EvenNumberValidator("Animals must have an even number of legs.")]
-        [PositiveNumberValidator("Number of legs must be greater than 0.")]
-        public int Legs { get; set; }
-    }
-}
+    [CommandArgument(1, "[LEGS]")]
+    [Description("The number of legs.")]
+    [EvenNumberValidator("Animals must have an even number of legs.")]
+    [PositiveNumberValidator("Number of legs must be greater than 0.")]
+    public int Legs { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/ArgumentOrderSettings.cs

@@ -1,22 +1,19 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class ArgumentOrderSettings : CommandSettings
 {
-    public sealed class ArgumentOrderSettings : CommandSettings
-    {
-        [CommandArgument(0, "[QUX]")]
-        public int Qux { get; set; }
+    [CommandArgument(0, "[QUX]")]
+    public int Qux { get; set; }
 
-        [CommandArgument(3, "<CORGI>")]
-        public int Corgi { get; set; }
+    [CommandArgument(3, "<CORGI>")]
+    public int Corgi { get; set; }
 
-        [CommandArgument(1, "<BAR>")]
-        public int Bar { get; set; }
+    [CommandArgument(1, "<BAR>")]
+    public int Bar { get; set; }
 
-        [CommandArgument(2, "<BAZ>")]
-        public int Baz { get; set; }
+    [CommandArgument(2, "<BAZ>")]
+    public int Baz { get; set; }
 
-        [CommandArgument(0, "<FOO>")]
-        public int Foo { get; set; }
-    }
-}
+    [CommandArgument(0, "<FOO>")]
+    public int Foo { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/ArgumentVectorSettings.cs

@@ -1,10 +1,7 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class ArgumentVectorSettings : CommandSettings
 {
-    public class ArgumentVectorSettings : CommandSettings
-    {
-        [CommandArgument(0, "<Foos>")]
-        public string[] Foo { get; set; }
-    }
-}
+    [CommandArgument(0, "<Foos>")]
+    public string[] Foo { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/BarCommandSettings.cs

@@ -1,12 +1,8 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class BarCommandSettings : FooCommandSettings
 {
-    public class BarCommandSettings : FooCommandSettings
-    {
-        [CommandArgument(0, "<CORGI>")]
-        [Description("The corgi value.")]
-        public string Corgi { get; set; }
-    }
-}
+    [CommandArgument(0, "<CORGI>")]
+    [Description("The corgi value.")]
+    public string Corgi { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/CatSettings.cs

@@ -1,15 +1,11 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class CatSettings : MammalSettings
 {
-    public class CatSettings : MammalSettings
-    {
-        [CommandOption("--agility <VALUE>")]
-        [TypeConverter(typeof(CatAgilityConverter))]
-        [DefaultValue(10)]
-        [Description("The agility between 0 and 100.")]
-        [PositiveNumberValidator("Agility cannot be negative.")]
-        public int Agility { get; set; }
-    }
-}
+    [CommandOption("--agility <VALUE>")]
+    [TypeConverter(typeof(CatAgilityConverter))]
+    [DefaultValue(10)]
+    [Description("The agility between 0 and 100.")]
+    [PositiveNumberValidator("Agility cannot be negative.")]
+    public int Agility { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/DogSettings.cs

@@ -1,23 +1,20 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class DogSettings : MammalSettings
 {
-    public sealed class DogSettings : MammalSettings
+    [CommandArgument(0, "<AGE>")]
+    public int Age { get; set; }
+
+    [CommandOption("-g|--good-boy")]
+    public bool GoodBoy { get; set; }
+
+    public override ValidationResult Validate()
     {
-        [CommandArgument(0, "<AGE>")]
-        public int Age { get; set; }
-
-        [CommandOption("-g|--good-boy")]
-        public bool GoodBoy { get; set; }
-
-        public override ValidationResult Validate()
+        if (Name == "Tiger")
         {
-            if (Name == "Tiger")
-            {
-                return ValidationResult.Error("Tiger is not a dog name!");
-            }
-
-            return ValidationResult.Success();
+            return ValidationResult.Error("Tiger is not a dog name!");
         }
+
+        return ValidationResult.Success();
     }
-}
+}

test/Spectre.Console.Tests/Data/Settings/EmptySettings.cs

@@ -1,8 +1,5 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class EmptySettings : CommandSettings
 {
-    public sealed class EmptySettings : CommandSettings
-    {
-    }
-}
+}

test/Spectre.Console.Tests/Data/Settings/FooSettings.cs

@@ -1,12 +1,8 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class FooCommandSettings : CommandSettings
 {
-    public class FooCommandSettings : CommandSettings
-    {
-        [CommandArgument(0, "[QUX]")]
-        [Description("The qux value.")]
-        public string Qux { get; set; }
-    }
-}
+    [CommandArgument(0, "[QUX]")]
+    [Description("The qux value.")]
+    public string Qux { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/GiraffeSettings.cs

@@ -1,12 +1,8 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class GiraffeSettings : MammalSettings
 {
-    public sealed class GiraffeSettings : MammalSettings
-    {
-        [CommandArgument(0, "<LENGTH>")]
-        [Description("The option description.")]
-        public int Length { get; set; }
-    }
-}
+    [CommandArgument(0, "<LENGTH>")]
+    [Description("The option description.")]
+    public int Length { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/HiddenOptionSettings.cs

@@ -1,20 +1,16 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class HiddenOptionSettings : CommandSettings
 {
-    public sealed class HiddenOptionSettings : CommandSettings
-    {
-        [CommandArgument(0, "<FOO>")]
-        [Description("Dummy argument FOO")]
-        public int Foo { get; set; }
+    [CommandArgument(0, "<FOO>")]
+    [Description("Dummy argument FOO")]
+    public int Foo { get; set; }
 
-        [CommandOption("--bar", IsHidden = true)]
-        [Description("You should not be able to read this unless you used the 'cli explain' command with the '--hidden' option")]
-        public int Bar { get; set; }
+    [CommandOption("--bar", IsHidden = true)]
+    [Description("You should not be able to read this unless you used the 'cli explain' command with the '--hidden' option")]
+    public int Bar { get; set; }
 
-        [CommandOption("--baz")]
-        [Description("Dummy option BAZ")]
-        public int Baz { get; set; }
-    }
-}
+    [CommandOption("--baz")]
+    [Description("Dummy option BAZ")]
+    public int Baz { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/InvalidSettings.cs

@@ -1,10 +1,7 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class InvalidSettings : CommandSettings
 {
-    public sealed class InvalidSettings : CommandSettings
-    {
-        [CommandOption("-f|--foo [BAR]")]
-        public string Value { get; set; }
-    }
-}
+    [CommandOption("-f|--foo [BAR]")]
+    public string Value { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/LionSettings.cs

@@ -1,16 +1,12 @@
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class LionSettings : CatSettings
 {
-    public class LionSettings : CatSettings
-    {
-        [CommandArgument(0, "<TEETH>")]
-        [Description("The number of teeth the lion has.")]
-        public int Teeth { get; set; }
+    [CommandArgument(0, "<TEETH>")]
+    [Description("The number of teeth the lion has.")]
+    public int Teeth { get; set; }
 
-        [CommandOption("-c <CHILDREN>")]
-        [Description("The number of children the lion has.")]
-        public int Children { get; set; }
-    }
-}
+    [CommandOption("-c <CHILDREN>")]
+    [Description("The number of children the lion has.")]
+    public int Children { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/MammalSettings.cs

@@ -1,10 +1,7 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class MammalSettings : AnimalSettings
 {
-    public class MammalSettings : AnimalSettings
-    {
-        [CommandOption("-n|-p|--name|--pet-name <VALUE>")]
-        public string Name { get; set; }
-    }
-}
+    [CommandOption("-n|-p|--name|--pet-name <VALUE>")]
+    public string Name { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/MultipleArgumentVectorSettings.cs

@@ -1,22 +1,19 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class MultipleArgumentVectorSettings : CommandSettings
 {
-    public class MultipleArgumentVectorSettings : CommandSettings
-    {
-        [CommandArgument(0, "<Foos>")]
-        public string[] Foo { get; set; }
+    [CommandArgument(0, "<Foos>")]
+    public string[] Foo { get; set; }
 
-        [CommandArgument(0, "<Bars>")]
-        public string[] Bar { get; set; }
-    }
+    [CommandArgument(0, "<Bars>")]
+    public string[] Bar { get; set; }
+}
 
-    public class MultipleArgumentVectorSpecifiedFirstSettings : CommandSettings
-    {
-        [CommandArgument(1, "[Bar]")]
-        public string Bar { get; set; }
+public class MultipleArgumentVectorSpecifiedFirstSettings : CommandSettings
+{
+    [CommandArgument(1, "[Bar]")]
+    public string Bar { get; set; }
 
-        [CommandArgument(0, "<Foos>")]
-        public string[] Foo { get; set; }
-    }
-}
+    [CommandArgument(0, "<Foos>")]
+    public string[] Foo { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/OptionVectorSettings.cs

@@ -1,13 +1,10 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public class OptionVectorSettings : CommandSettings
 {
-    public class OptionVectorSettings : CommandSettings
-    {
-        [CommandOption("--foo")]
-        public string[] Foo { get; set; }
+    [CommandOption("--foo")]
+    public string[] Foo { get; set; }
 
-        [CommandOption("--bar")]
-        public int[] Bar { get; set; }
-    }
-}
+    [CommandOption("--bar")]
+    public int[] Bar { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/OptionalArgumentWithDefaultValueSettings.cs

@@ -1,40 +1,35 @@
-using System;
-using System.ComponentModel;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class OptionalArgumentWithDefaultValueSettings : CommandSettings
 {
-    public sealed class OptionalArgumentWithDefaultValueSettings : CommandSettings
-    {
-        [CommandArgument(0, "[GREETING]")]
-        [DefaultValue("Hello World")]
-        public string Greeting { get; set; }
-    }
+    [CommandArgument(0, "[GREETING]")]
+    [DefaultValue("Hello World")]
+    public string Greeting { get; set; }
+}
 
-    public sealed class OptionalArgumentWithPropertyInitializerSettings : CommandSettings
-    {
-        [CommandArgument(0, "[NAMES]")]
-        public string[] Names { get; set; } = Array.Empty<string>();
+public sealed class OptionalArgumentWithPropertyInitializerSettings : CommandSettings
+{
+    [CommandArgument(0, "[NAMES]")]
+    public string[] Names { get; set; } = Array.Empty<string>();
 
-        [CommandOption("-c")]
-        public int Count { get; set; } = 1;
+    [CommandOption("-c")]
+    public int Count { get; set; } = 1;
 
-        [CommandOption("-v")]
-        public int Value { get; set; } = 0;
-    }
+    [CommandOption("-v")]
+    public int Value { get; set; } = 0;
+}
 
-    public sealed class OptionalArgumentWithDefaultValueAndTypeConverterSettings : CommandSettings
-    {
-        [CommandArgument(0, "[GREETING]")]
-        [DefaultValue("5")]
-        [TypeConverter(typeof(StringToIntegerConverter))]
-        public int Greeting { get; set; }
-    }
+public sealed class OptionalArgumentWithDefaultValueAndTypeConverterSettings : CommandSettings
+{
+    [CommandArgument(0, "[GREETING]")]
+    [DefaultValue("5")]
+    [TypeConverter(typeof(StringToIntegerConverter))]
+    public int Greeting { get; set; }
+}
 
-    public sealed class RequiredArgumentWithDefaultValueSettings : CommandSettings
-    {
-        [CommandArgument(0, "<GREETING>")]
-        [DefaultValue("Hello World")]
-        public string Greeting { get; set; }
-    }
-}
+public sealed class RequiredArgumentWithDefaultValueSettings : CommandSettings
+{
+    [CommandArgument(0, "<GREETING>")]
+    [DefaultValue("Hello World")]
+    public string Greeting { get; set; }
+}

test/Spectre.Console.Tests/Data/Settings/StringOptionSettings.cs

@@ -1,10 +1,7 @@
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+public sealed class StringOptionSettings : CommandSettings
 {
-    public sealed class StringOptionSettings : CommandSettings
-    {
-        [CommandOption("-f|--foo")]
-        public string Foo { get; set; }
-    }
-}
+    [CommandOption("-f|--foo")]
+    public string Foo { get; set; }
+}

test/Spectre.Console.Tests/Data/Validators/EvenNumberValidatorAttribute.cs

@@ -1,29 +1,25 @@
-using System;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+public sealed class EvenNumberValidatorAttribute : ParameterValidationAttribute
 {
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
-    public sealed class EvenNumberValidatorAttribute : ParameterValidationAttribute
+    public EvenNumberValidatorAttribute(string errorMessage)
+        : base(errorMessage)
     {
-        public EvenNumberValidatorAttribute(string errorMessage)
-            : base(errorMessage)
-        {
-        }
+    }
 
-        public override ValidationResult Validate(CommandParameterContext context)
+    public override ValidationResult Validate(CommandParameterContext context)
+    {
+        if (context.Value is int integer)
         {
-            if (context.Value is int integer)
+            if (integer % 2 == 0)
             {
-                if (integer % 2 == 0)
-                {
-                    return ValidationResult.Success();
-                }
-
-                return ValidationResult.Error($"Number is not even ({context.Parameter.PropertyName}).");
+                return ValidationResult.Success();
             }
 
-            throw new InvalidOperationException($"Parameter is not a number ({context.Parameter.PropertyName}).");
+            return ValidationResult.Error($"Number is not even ({context.Parameter.PropertyName}).");
         }
+
+        throw new InvalidOperationException($"Parameter is not a number ({context.Parameter.PropertyName}).");
     }
-}
+}

test/Spectre.Console.Tests/Data/Validators/PositiveNumberValidatorAttribute.cs

@@ -1,29 +1,25 @@
-using System;
-using Spectre.Console.Cli;
+namespace Spectre.Console.Tests.Data;
 
-namespace Spectre.Console.Tests.Data
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+public sealed class PositiveNumberValidatorAttribute : ParameterValidationAttribute
 {
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
-    public sealed class PositiveNumberValidatorAttribute : ParameterValidationAttribute
+    public PositiveNumberValidatorAttribute(string errorMessage)
+        : base(errorMessage)
     {
-        public PositiveNumberValidatorAttribute(string errorMessage)
-            : base(errorMessage)
-        {
-        }
+    }
 
-        public override ValidationResult Validate(CommandParameterContext context)
+    public override ValidationResult Validate(CommandParameterContext context)
+    {
+        if (context.Value is int integer)
         {
-            if (context.Value is int integer)
+            if (integer > 0)
             {
-                if (integer > 0)
-                {
-                    return ValidationResult.Success();
-                }
-
-                return ValidationResult.Error($"Number is not greater than 0 ({context.Parameter.PropertyName}).");
+                return ValidationResult.Success();
             }
 
-            throw new InvalidOperationException($"Parameter is not a number ({context.Parameter.PropertyName}).");
+            return ValidationResult.Error($"Number is not greater than 0 ({context.Parameter.PropertyName}).");
         }
+
+        throw new InvalidOperationException($"Parameter is not a number ({context.Parameter.PropertyName}).");
     }
-}
+}