remove ValueForArgument<T>(Argument) and ValueForOption<T>(Option)

Author: jonsequitur

src/System.CommandLine.Tests/ArgumentTests.cs

@@ -452,25 +452,27 @@ public void When_custom_conversion_fails_then_an_option_does_not_accept_further_
             [Fact]
             public void When_argument_cannot_be_parsed_as_the_specified_type_then_getting_value_throws()
             {
-                var command = new Command("the-command")
+                var option = new Option<int>(new[] { "-o", "--one" }, argumentResult =>
                 {
-                    new Option<int>(new[] { "-o", "--one" }, argumentResult =>
-                        {
-                            if (int.TryParse(argumentResult.Tokens.Select(t => t.Value).Single(), out var value))
-                            {
-                                return value;
-                            }
+                    if (int.TryParse(argumentResult.Tokens.Select(t => t.Value).Single(), out var value))
+                    {
+                        return value;
+                    }
 
-                            argumentResult.ErrorMessage = $"'{argumentResult.Tokens.Single().Value}' is not an integer";
+                    argumentResult.ErrorMessage = $"'{argumentResult.Tokens.Single().Value}' is not an integer";
 
-                            return default;
-                        })
+                    return default;
+                });
+
+                var command = new Command("the-command")
+                {
+                    option
                 };
 
                 var result = command.Parse("the-command -o not-an-int");
 
-                Action getValue = () =>
-                    result.ValueForOption("-o");
+                Action getValue = () => 
+                    result.ValueForOption(option);
 
                 getValue.Should()
                         .Throw<InvalidOperationException>()

src/System.CommandLine.Tests/Binding/TypeConversionTests.cs

@@ -182,46 +182,52 @@ public void Bool_does_not_parse_as_the_default_value_when_the_option_has_been_ap
         }
 
         [Fact]
-        public void By_default_an_option_with_zero_or_one_argument_parses_as_the_argument_string_value_by_default()
+        public void By_default_an_option_with_zero_or_one_argument_parses_as_the_argument_string_value()
         {
+            var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.ZeroOrOne)
+                option
             };
 
             var result = command.Parse("the-command -x the-argument");
 
-            result.ValueForOption("-x")
+            result.ValueForOption(option)
                   .Should()
                   .Be("the-argument");
         }
 
         [Fact]
-        public void By_default_an_option_with_exactly_one_argument_parses_as_the_argument_string_value_by_default()
+        public void By_default_an_option_with_exactly_one_argument_parses_as_the_argument_string_value()
         {
+            var option = new Option("-x", arity: ArgumentArity.ExactlyOne);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.ExactlyOne)
+                option
             };
 
             var result = command.Parse("the-command -x the-argument");
 
-            result.ValueForOption("-x")
+            result.ValueForOption(option)
                   .Should()
                   .Be("the-argument");
         }
 
         [Fact]
         public void When_exactly_one_argument_is_expected_and_none_are_provided_then_getting_value_throws()
         {
+            var option = new Option("-x", arity: ArgumentArity.ExactlyOne);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.ExactlyOne)
+                option
             };
 
             var result = command.Parse("the-command -x");
 
-            Action getValue = () => result.ValueForOption("-x");
+            Action getValue = () => result.ValueForOption(option);
 
             getValue.Should()
                     .Throw<InvalidOperationException>()
@@ -234,14 +240,16 @@ public void When_exactly_one_argument_is_expected_and_none_are_provided_then_get
         [Fact]
         public void When_zero_or_more_arguments_of_unspecified_type_are_expected_and_none_are_provided_then_getting_value_returns_an_empty_sequence_of_strings()
         {
+            var option = new Option("-x", arity: ArgumentArity.ZeroOrMore);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.ZeroOrMore)
+                option
             };
 
             var result = command.Parse("the-command -x");
 
-            result.ValueForOption("-x")
+            result.ValueForOption(option)
                   .Should()
                   .BeAssignableTo<IReadOnlyCollection<string>>()
                   .Which
@@ -262,7 +270,7 @@ public void
 
             var result = command.Parse("the-command");
 
-            result.ValueForOption("-x")
+            result.ValueForOption(option)
                   .Should()
                   .BeAssignableTo<IReadOnlyCollection<string>>()
                   .Which
@@ -273,14 +281,16 @@ public void
         [Fact]
         public void When_one_or_more_arguments_of_unspecified_type_are_expected_and_none_are_provided_then_getting_value_throws()
         {
+            var option = new Option("-x", arity: ArgumentArity.OneOrMore);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.OneOrMore)
+                option
             };
 
             var result = command.Parse("the-command -x");
 
-            Action getValue = () => result.ValueForOption("-x");
+            Action getValue = () => result.ValueForOption(option);
 
             getValue.Should()
                     .Throw<InvalidOperationException>()
@@ -293,27 +303,31 @@ public void When_one_or_more_arguments_of_unspecified_type_are_expected_and_none
         [Fact]
         public void By_default_an_option_that_allows_multiple_arguments_and_is_passed_multiple_arguments_parses_as_a_sequence_of_strings()
         {
+            var option = new Option("-x", arity: ArgumentArity.ZeroOrMore);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.ZeroOrMore)
+                option
             };
 
             command.Parse("the-command -x arg1 -x arg2")
-                   .ValueForOption("-x")
+                   .ValueForOption(option)
                    .Should()
                    .BeEquivalentTo(new[] { "arg1", "arg2" });
         }
 
         [Fact]
         public void By_default_an_option_that_allows_multiple_arguments_and_is_passed_one_argument_parses_as_a_sequence_of_strings()
         {
+            var option = new Option("-x", arity: ArgumentArity.ZeroOrMore);
+
             var command = new Command("the-command")
             {
-                new Option("-x", arity: ArgumentArity.ZeroOrMore)
+                option
             };
 
             command.Parse("the-command -x arg1")
-                   .ValueForOption("-x")
+                   .ValueForOption(option)
                    .Should()
                    .BeEquivalentTo(new[] { "arg1" });
         }
@@ -324,24 +338,26 @@ public void By_default_an_option_that_allows_multiple_arguments_and_is_passed_on
         [InlineData("c c c")]
         public void When_command_argument_has_arity_greater_than_one_it_captures_arguments_before_and_after_option(string commandLine)
         {
+            var argument = new Argument<string[]>("the-arg")
+            {
+                Arity = ArgumentArity.ZeroOrMore
+            };
+
             var command = new Command("the-command")
             {
                 new Option<string>("-a"),
-                new Argument<string>("the-arg")
-                {
-                    Arity = ArgumentArity.ZeroOrMore
-                }
+                argument
             };
 
             var result = command.Parse(commandLine);
 
-            result.ValueForArgument("the-arg")
+            result.ValueForArgument(argument)
                   .Should()
                   .BeEquivalentTo(new[] { "c", "c", "c" });
         }
 
         [Fact]
-        public void The_default_value_of_an_option_with_no_arguments_is_false()
+        public void The_default_value_of_an_option_with_no_arguments_is_true()
         {
             var option = new Option("-x");
 
@@ -353,8 +369,7 @@ public void The_default_value_of_an_option_with_no_arguments_is_false()
 
             var result = command.Parse("-x");
 
-            result.FindResultFor(option)
-                  .GetValueOrDefault()
+            result.ValueForOption(option)
                   .Should()
                   .Be(true);
         }
@@ -371,9 +386,9 @@ public void By_default_an_option_without_arguments_parses_as_false_when_it_is_no
 
             var result = command.Parse("something");
 
-            result.ValueForOption<bool>(option)
+            result.ValueForOption(option)
                   .Should()
-                  .BeFalse();
+                  .Be(false);
         }
 
         [Fact]
@@ -442,83 +457,28 @@ public void A_default_value_with_a_custom_constructor_can_be_specified_for_a_com
 
             result.Errors.Should().BeEmpty();
 
-            var value = result.ValueForArgument("the-arg");
+            var value = result.ValueForArgument(argument);
 
             value.Should().Be(directoryInfo);
         }
 
         [Fact]
-        public void An_option_argument_with_a_default_argument_can_be_converted_to_the_requested_type()
+        public void Specifying_an_option_argument_overrides_the_default_value()
         {
-            var option = new Option<string>("-x", () => "123");
+            var option = new Option<int>("-x", () => 123);
 
             var command = new Command("something")
             {
                 option
             };
 
-            var result = command.Parse("something");
-
-            var value = result.ValueForOption<int>(option);
-
-            value.Should().Be(123);
-        }
-
-        [Fact]
-        public void Specifying_an_option_argument_overrides_the_default_value()
-        {
-            var command = new Command("something")
-            {
-                new Option<int>("-x", () => 123)
-            };
-
             var result = command.Parse("something -x 456");
 
-            var value = result.ValueForOption<int>("-x");
+            var value = result.ValueForOption(option);
 
             value.Should().Be(456);
         }
-
-        [Fact]
-        public void Values_can_be_correctly_converted_to_int_without_the_parser_specifying_a_custom_converter()
-        {
-            var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
-
-            var value = option.Parse("-x 123").ValueForOption<int>(option);
-
-            value.Should().Be(123);
-        }
-
-        [Fact]
-        public void Values_can_be_correctly_converted_to_nullable_int_with_no_value_without_the_parser_specifying_a_custom_converter()
-        {
-            var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
-
-            var value = option.Parse("").ValueForOption<int?>("-x");
-
-            value.Should().BeNull();
-        }
-
-        [Fact]
-        public void Values_can_be_correctly_converted_to_nullable_int_with_a_value_without_the_parser_specifying_a_custom_converter()
-        {
-            var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
-
-            var value = option.Parse("-x 123").ValueForOption<int?>(option);
-
-            value.Should().Be(123);
-        }
-
-        [Fact]
-        public void Values_can_be_correctly_converted_to_decimal_without_the_parser_specifying_a_custom_converter()
-        {
-            var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
-
-            var value = option.Parse("-x 123.456").ValueForOption<decimal>(option);
-
-            value.Should().Be(123.456m);
-        }
-
+      
         [Fact]
         public void Values_can_be_correctly_converted_to_double_without_the_parser_specifying_a_custom_converter()
         {

src/System.CommandLine.Tests/Invocation/CommandHandlerTests.cs

@@ -260,15 +260,17 @@ public async Task Method_parameters_of_type_ParseResult_receive_the_current_Pars
         {
             ParseResult boundParseResult = default;
 
+            var option = new Option<int>("-x");
+
             var command = new Command("command")
             {
-                new Option<int>("-x")
+                option
             };
             command.Handler = CommandHandler.Create<ParseResult>(result => { boundParseResult = result; });
 
             await command.InvokeAsync("command -x 123", _console);
 
-            boundParseResult.ValueForOption("-x").Should().Be(123);
+            boundParseResult.ValueForOption(option).Should().Be(123);
         }
 
         [Fact]
@@ -307,15 +309,17 @@ public async Task Method_parameters_of_type_InvocationContext_receive_the_curren
         {
             InvocationContext boundContext = default;
 
+            var option = new Option<int>("-x");
+
             var command = new Command("command")
             {
-                new Option<int>("-x")
+                option
             };
             command.Handler = CommandHandler.Create<InvocationContext>(context => { boundContext = context; });
 
             await command.InvokeAsync("command -x 123", _console);
 
-            boundContext.ParseResult.ValueForOption("-x").Should().Be(123);
+            boundContext.ParseResult.ValueForOption(option).Should().Be(123);
         }