style: run dotnet-format

natemcmaster · natemcmaster · commit 833e9c223078 · 2019-06-20T00:11:02.000-07:00
diff --git a/.editorconfig b/.editorconfig
@@ -25,7 +25,7 @@ dotnet_sort_system_directives_first                                    = true
 # Stuff that is usually best
 csharp_style_inlined_variable_declaration                              = true
 csharp_style_var_elsewhere                                             = true
-csharp_space_after_cast                                                = true
+csharp_space_after_cast                                                = false
 csharp_style_pattern_matching_over_as_with_null_check                  = true
 csharp_style_pattern_matching_over_is_with_cast_check                  = true
 csharp_style_var_for_built_in_types                                    = true
diff --git a/src/CommandLineUtils/Conventions/ConstructorInjectionConvention.cs b/src/CommandLineUtils/Conventions/ConstructorInjectionConvention.cs
@@ -62,7 +62,7 @@ private void ApplyImpl<TModel>(ConventionContext context)
 
             if (factory != null)
             {
-                ((CommandLineApplication<TModel>) context.Application).ModelFactory = factory;
+                ((CommandLineApplication<TModel>)context.Application).ModelFactory = factory;
             }
         }
 
@@ -104,11 +104,11 @@ private void ApplyImpl<TModel>(ConventionContext context)
                     args[i] = service;
                     if (i == parameters.Length - 1)
                     {
-                        return () => (TModel) ctorCandidate.Invoke(args);
+                        return () => (TModel)ctorCandidate.Invoke(args);
                     }
                 }
 
-                nextCtor: ;
+            nextCtor:;
             }
 
             return () => throw new InvalidOperationException(Strings.NoMatchedConstructorFound(typeof(TModel)));
diff --git a/src/CommandLineUtils/Conventions/ExecuteMethodConvention.cs b/src/CommandLineUtils/Conventions/ExecuteMethodConvention.cs
@@ -80,7 +80,7 @@ private async Task<int> InvokeAsync(MethodInfo method, object instance, object[]
         {
             try
             {
-                var result = (Task) method.Invoke(instance, arguments);
+                var result = (Task)method.Invoke(instance, arguments);
                 if (result is Task<int> intResult)
                 {
                     return await intResult;
@@ -103,7 +103,7 @@ private int Invoke(MethodInfo method, object instance, object[] arguments)
                 var result = method.Invoke(instance, arguments);
                 if (method.ReturnType == typeof(int))
                 {
-                    return (int) result;
+                    return (int)result;
                 }
             }
             catch (TargetInvocationException e)
diff --git a/src/CommandLineUtils/Internal/AnsiConsole.cs b/src/CommandLineUtils/Internal/AnsiConsole.cs
@@ -62,7 +62,7 @@ public void WriteLine(string message)
             }
 
             var escapeScan = 0;
-            for (; ;)
+            for (; ; )
             {
                 var escapeIndex = message.IndexOf("\x1b[", escapeScan);
                 if (escapeIndex == -1)
diff --git a/src/CommandLineUtils/Internal/CommandLineProcessor.cs b/src/CommandLineUtils/Internal/CommandLineProcessor.cs
@@ -399,10 +399,12 @@ public CommandOrParameterArgument(string raw) : base(raw)
 
         private class OptionArgument : Argument
         {
+            private static readonly char[] NameValueSeparators = { ':', '=' };
+
             public OptionArgument(string raw, bool isShortOption) : base(raw)
             {
                 IsShortOption = isShortOption;
-                var parts = Raw.Split(new[] { ':', '=' }, 2);
+                var parts = Raw.Split(NameValueSeparators, 2);
                 if (parts.Length > 1)
                 {
                     Value = parts[1];
@@ -414,8 +416,8 @@ public OptionArgument(string raw, bool isShortOption) : base(raw)
                 Name = parts[0].Substring(sublen);
             }
 
-            public string Name { get; set; }
-            public string? Value { get; set; }
+            public string Name { get; }
+            public string? Value { get; }
             public bool IsShortOption { get; }
         }
 
diff --git a/src/CommandLineUtils/Internal/StringDistance.cs b/src/CommandLineUtils/Internal/StringDistance.cs
@@ -123,7 +123,7 @@ internal static double NormalizeDistance(int distance, int length)
                 return 1;
             }
 
-            return 1.0d - distance / (double) length;
+            return 1.0d - distance / (double)length;
         }
 
         /// <summary>
diff --git a/src/CommandLineUtils/Internal/ValueParsers/StockValueParsers.cs b/src/CommandLineUtils/Internal/ValueParsers/StockValueParsers.cs
@@ -58,23 +58,23 @@ private static IValueParser<T> FloatingPointParser<T>(NumberParser<T> parser) =>
                    (argName, value) => InvalidValueException(argName, $"'{value}' is not a valid floating-point number."));
 
         public static readonly IValueParser<double> Double = FloatingPointParser<double>(double.TryParse);
-        public static readonly IValueParser<float>  Float  = FloatingPointParser<float> (float.TryParse );
+        public static readonly IValueParser<float> Float = FloatingPointParser<float>(float.TryParse);
 
         private static IValueParser<T> IntegerParser<T>(NumberParser<T> parser) =>
             Create(parser, NumberStyles.Integer, (argName, value) => InvalidValueException(argName, $"'{value}' is not a valid number."));
 
         public static readonly IValueParser<short> Int16 = IntegerParser<short>(short.TryParse);
-        public static readonly IValueParser<int>   Int32 = IntegerParser<int>  (int.TryParse  );
-        public static readonly IValueParser<long>  Int64 = IntegerParser<long> (long.TryParse );
+        public static readonly IValueParser<int> Int32 = IntegerParser<int>(int.TryParse);
+        public static readonly IValueParser<long> Int64 = IntegerParser<long>(long.TryParse);
 
         private static IValueParser<T> NonNegativeIntegerParser<T>(NumberParser<T> parser) =>
             Create(parser, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                    (argName, value) => InvalidValueException(argName, $"'{value}' is not a valid, non-negative number."));
 
-        public static readonly IValueParser<byte>   Byte   = NonNegativeIntegerParser<byte>  (byte.TryParse  );
+        public static readonly IValueParser<byte> Byte = NonNegativeIntegerParser<byte>(byte.TryParse);
         public static readonly IValueParser<ushort> UInt16 = NonNegativeIntegerParser<ushort>(ushort.TryParse);
-        public static readonly IValueParser<uint>   UInt32 = NonNegativeIntegerParser<uint>  (uint.TryParse  );
-        public static readonly IValueParser<ulong>  UInt64 = NonNegativeIntegerParser<ulong> (ulong.TryParse );
+        public static readonly IValueParser<uint> UInt32 = NonNegativeIntegerParser<uint>(uint.TryParse);
+        public static readonly IValueParser<ulong> UInt64 = NonNegativeIntegerParser<ulong>(ulong.TryParse);
 
         private delegate bool DateTimeParser<T>(string s, IFormatProvider provider, DateTimeStyles styles, out T result);
 
diff --git a/src/CommandLineUtils/Utilities/ArgumentEscaper.cs b/src/CommandLineUtils/Utilities/ArgumentEscaper.cs
@@ -93,6 +93,6 @@ private static bool IsSurroundedWithQuotes(string argument)
         }
 
         private static bool ContainsWhitespace(string argument)
-            => argument.IndexOfAny(new [] { ' ', '\t', '\n' }) >= 0;
+            => argument.IndexOfAny(new[] { ' ', '\t', '\n' }) >= 0;
     }
 }
diff --git a/test/CommandLineUtils.Tests/CommandLineApplicationTests.cs b/test/CommandLineUtils.Tests/CommandLineApplicationTests.cs
@@ -44,7 +44,8 @@ public void CommandNameCanBeMatched()
         public void CommandsNamesAreCaseInsensitive()
         {
             var app = new CommandLineApplication();
-            var cmd = app.Command("TEST", c => {
+            var cmd = app.Command("TEST", c =>
+            {
                 c.OnExecute(() => 5);
             });
             cmd.AddName("TE");
@@ -106,10 +107,10 @@ public void ItThrowsIfAnotherSubcommandHasNameName()
                 c.AddName("s");
             });
 
-            var ex = Assert.Throws<InvalidOperationException>(() => app.Command("sub1", _ => {}));
+            var ex = Assert.Throws<InvalidOperationException>(() => app.Command("sub1", _ => { }));
             Assert.Equal(Strings.DuplicateSubcommandName("sub1"), ex.Message);
 
-            ex = Assert.Throws<InvalidOperationException>(() => app.Command("s", _ => {}));
+            ex = Assert.Throws<InvalidOperationException>(() => app.Command("s", _ => { }));
             Assert.Equal(Strings.DuplicateSubcommandName("s"), ex.Message);
         }
 
@@ -947,7 +948,7 @@ public void LongOptionsCanBeCaseInsensitive()
         public void CommandNamesMatchingIsCaseInsensitive()
         {
             var app = new CommandLineApplication(throwOnUnexpectedArg: false);
-            var cmd = app.Command("CMD1", _ => {});
+            var cmd = app.Command("CMD1", _ => { });
 
             Assert.Same(cmd, app.Parse("CMD1").SelectedCommand);
             Assert.Same(cmd, app.Parse("cmd1").SelectedCommand);
diff --git a/test/CommandLineUtils.Tests/CommandNameFromTypeConventionTests.cs b/test/CommandLineUtils.Tests/CommandNameFromTypeConventionTests.cs
@@ -19,10 +19,10 @@ public void ItInfersCommandName(string typeName, string commandName)
 
         [Subcommand(typeof(AddCommand))]
         private class Program
-        {}
+        { }
 
         private class AddCommand
-        {}
+        { }
 
         [Fact]
         public void ItInfersSubcommandNameFromTypeName()
diff --git a/test/CommandLineUtils.Tests/HelpOptionAttributeTests.cs b/test/CommandLineUtils.Tests/HelpOptionAttributeTests.cs
@@ -167,7 +167,7 @@ public void HelpOptionIsInherited()
         {
             var sb = new StringBuilder();
             var outWriter = new StringWriter(sb);
-            var app = new CommandLineApplication<Parent> {Out = outWriter};
+            var app = new CommandLineApplication<Parent> { Out = outWriter };
             app.Conventions.UseDefaultConventions();
             app.Commands.ForEach(f => f.Out = outWriter);
             app.Execute("lvl2", "--help");
@@ -204,7 +204,8 @@ public void NestedHelpOptionsChoosesHelpOptionNearestSelectedCommand(string[] ar
                 });
             });
 
-            app.OnExecute(() => {
+            app.OnExecute(() =>
+            {
                 app.ShowHelp();
                 return 1;
             });
diff --git a/test/CommandLineUtils.Tests/StringDistanceTests.cs b/test/CommandLineUtils.Tests/StringDistanceTests.cs
@@ -107,8 +107,8 @@ public void SortedMatches(string value, string candidates, string expectedOutput
         [Fact]
         public void MatchingWithNullReturnsNull()
         {
-            Assert.Empty(StringDistance.GetBestMatchesSorted(null, "", new []{ ""}, 0));
-            Assert.Empty(StringDistance.GetBestMatchesSorted((s, s1) => 1, null, new []{ ""}, 0));
+            Assert.Empty(StringDistance.GetBestMatchesSorted(null, "", new[] { "" }, 0));
+            Assert.Empty(StringDistance.GetBestMatchesSorted((s, s1) => 1, null, new[] { "" }, 0));
             Assert.Empty(StringDistance.GetBestMatchesSorted((s, s1) => 1, "", null, 0));
         }
 
diff --git a/test/CommandLineUtils.Tests/SubcommandAttributeTests.cs b/test/CommandLineUtils.Tests/SubcommandAttributeTests.cs
@@ -190,7 +190,7 @@ private void OnExecute()
 
         [Command("LEVEL1")]
         private class Level1DuplicateCmd
-        {}
+        { }
 
         [Fact]
         public void CommandNamesCannotDifferByCaseOnly()
diff --git a/test/CommandLineUtils.Tests/ValidateMethodConventionTests.cs b/test/CommandLineUtils.Tests/ValidateMethodConventionTests.cs
@@ -79,8 +79,8 @@ private ValidationResult OnValidate(ValidationContext context, CommandLineContex
                 }
 
                 Assert.Equal(typeof(CommandLineApplication<SubcommandValidate>), context.ObjectInstance.GetType());
-                var subcommand = (CommandLineApplication<SubcommandValidate>) context.ObjectInstance;
-                var main = (CommandLineApplication<MainValidate>?) subcommand.Parent;
+                var subcommand = (CommandLineApplication<SubcommandValidate>)context.ObjectInstance;
+                var main = (CommandLineApplication<MainValidate>?)subcommand.Parent;
 
                 var middle = main?.Model.Middle;
                 if (middle.HasValue)
diff --git a/test/CommandLineUtils.Tests/ValidationTests.cs b/test/CommandLineUtils.Tests/ValidationTests.cs
@@ -100,7 +100,7 @@ public void RequiredOption_Attribute_Pass()
             Assert.Equal(0, CommandLineApplication.Execute<RequiredOption>("-p", "p"));
         }
 
-// Workaround https://github.com/dotnet/roslyn/issues/33199 https://github.com/xunit/xunit/issues/1897
+        // Workaround https://github.com/dotnet/roslyn/issues/33199 https://github.com/xunit/xunit/issues/1897
 #nullable disable
         [Theory]
         [InlineData(null)]
diff --git a/test/CommandLineUtils.Tests/ValueParserProviderTests.cs b/test/CommandLineUtils.Tests/ValueParserProviderTests.cs
@@ -128,7 +128,7 @@ public void Dispose()
             }
         }
 
-// Workaround https://github.com/dotnet/roslyn/issues/33199 https://github.com/xunit/xunit/issues/1897
+        // Workaround https://github.com/dotnet/roslyn/issues/33199 https://github.com/xunit/xunit/issues/1897
 #nullable disable
         public static IEnumerable<object[]> GetFloatingPointSymbolsData()
         {
diff --git a/test/Hosting.CommandLine.Tests/HostBuilderExtensionsTests.cs b/test/Hosting.CommandLine.Tests/HostBuilderExtensionsTests.cs
@@ -51,7 +51,7 @@ public async void TestConventionInjection()
             var convention = new Mock<IConvention>();
             convention.Setup(c => c.Apply(It.IsAny<ConventionContext>()))
                 .Callback((ConventionContext c) => c.Application.ThrowOnUnexpectedArgument = false).Verifiable();
-            var args = new[] {"Capture", "some", "test", "arguments"};
+            var args = new[] { "Capture", "some", "test", "arguments" };
             await new HostBuilder()
                 .ConfigureServices(collection => collection
                     .AddSingleton<IConsole>(new TestConsole(_output))
@@ -68,10 +68,10 @@ public void ItThrowsOnUnknownSubCommand()
             var ex = Assert.Throws<UnrecognizedCommandParsingException>(
                 () => new HostBuilder()
                     .ConfigureServices(collection => collection.AddSingleton<IConsole>(new TestConsole(_output)))
-                    .RunCommandLineApplicationAsync<ParentCommand>(new string[] {"return41"})
+                    .RunCommandLineApplicationAsync<ParentCommand>(new string[] { "return41" })
                     .GetAwaiter()
                     .GetResult());
-            Assert.Equal(new string[] {"return42"}, ex.NearestMatches);
+            Assert.Equal(new string[] { "return42" }, ex.NearestMatches);
         }
 
         [Fact]

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ private void ApplyImpl<TModel>(ConventionContext context)`
`62`	`62`
`63`	`63`	`if (factory != null)`
`64`	`64`	`{`
`65`		`- ((CommandLineApplication<TModel>) context.Application).ModelFactory = factory;`
	`65`	`+ ((CommandLineApplication<TModel>)context.Application).ModelFactory = factory;`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`@@ -104,11 +104,11 @@ private void ApplyImpl<TModel>(ConventionContext context)`
`104`	`104`	`args[i] = service;`
`105`	`105`	`if (i == parameters.Length - 1)`
`106`	`106`	`{`
`107`		`- return () => (TModel) ctorCandidate.Invoke(args);`
	`107`	`+ return () => (TModel)ctorCandidate.Invoke(args);`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- nextCtor: ;`
	`111`	`+ nextCtor:;`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`return () => throw new InvalidOperationException(Strings.NoMatchedConstructorFound(typeof(TModel)));`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ private async Task<int> InvokeAsync(MethodInfo method, object instance, object[]`
`80`	`80`	`{`
`81`	`81`	`try`
`82`	`82`	`{`
`83`		`- var result = (Task) method.Invoke(instance, arguments);`
	`83`	`+ var result = (Task)method.Invoke(instance, arguments);`
`84`	`84`	`if (result is Task<int> intResult)`
`85`	`85`	`{`
`86`	`86`	`return await intResult;`
`@@ -103,7 +103,7 @@ private int Invoke(MethodInfo method, object instance, object[] arguments)`
`103`	`103`	`var result = method.Invoke(instance, arguments);`
`104`	`104`	`if (method.ReturnType == typeof(int))`
`105`	`105`	`{`
`106`		`- return (int) result;`
	`106`	`+ return (int)result;`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`catch (TargetInvocationException e)`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ public void WriteLine(string message)`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`var escapeScan = 0;`
`65`		`- for (; ;)`
	`65`	`+ for (; ; )`
`66`	`66`	`{`
`67`	`67`	`var escapeIndex = message.IndexOf("\x1b[", escapeScan);`
`68`	`68`	`if (escapeIndex == -1)`
Original file line number	Diff line number	Diff line change
`@@ -399,10 +399,12 @@ public CommandOrParameterArgument(string raw) : base(raw)`
`399`	`399`
`400`	`400`	`private class OptionArgument : Argument`
`401`	`401`	`{`
	`402`	`+ private static readonly char[] NameValueSeparators = { ':', '=' };`
	`403`	`+`
`402`	`404`	`public OptionArgument(string raw, bool isShortOption) : base(raw)`
`403`	`405`	`{`
`404`	`406`	`IsShortOption = isShortOption;`
`405`		`- var parts = Raw.Split(new[] { ':', '=' }, 2);`
	`407`	`+ var parts = Raw.Split(NameValueSeparators, 2);`
`406`	`408`	`if (parts.Length > 1)`
`407`	`409`	`{`
`408`	`410`	`Value = parts[1];`
`@@ -414,8 +416,8 @@ public OptionArgument(string raw, bool isShortOption) : base(raw)`
`414`	`416`	`Name = parts[0].Substring(sublen);`
`415`	`417`	`}`
`416`	`418`
`417`		`- public string Name { get; set; }`
`418`		`- public string? Value { get; set; }`
	`419`	`+ public string Name { get; }`
	`420`	`+ public string? Value { get; }`
`419`	`421`	`public bool IsShortOption { get; }`
`420`	`422`	`}`
`421`	`423`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ internal static double NormalizeDistance(int distance, int length)`
`123`	`123`	`return 1;`
`124`	`124`	`}`
`125`	`125`
`126`		`- return 1.0d - distance / (double) length;`
	`126`	`+ return 1.0d - distance / (double)length;`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -93,6 +93,6 @@ private static bool IsSurroundedWithQuotes(string argument)`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`private static bool ContainsWhitespace(string argument)`
`96`		`- => argument.IndexOfAny(new [] { ' ', '\t', '\n' }) >= 0;`
	`96`	`+ => argument.IndexOfAny(new[] { ' ', '\t', '\n' }) >= 0;`
`97`	`97`	`}`
`98`	`98`	`}`