re #1127 remove from ParseResult: ValueForOption(string), ValueForArgument(string), string indexer

Author: jonsequitur

src/System.CommandLine.Tests/ArgumentTests.cs

@@ -451,25 +451,26 @@ 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");
+                    result.ValueForOption(option);
 
                 getValue.Should()
                         .Throw<InvalidOperationException>()

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

@@ -183,44 +183,47 @@ 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()
         {
+            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()
         {
+            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>()
@@ -233,14 +236,15 @@ 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
@@ -253,15 +257,14 @@ public void
             When_zero_or_more_arguments_of_unspecified_type_are_expected_and_none_are_provided_and_there_is_a_default_then_getting_value_returns_default_in_an_empty_sequence_of_strings()
         {
             var option = new Option("-x", getDefaultValue: () => "the-default", arity: ArgumentArity.ZeroOrMore);
-
             var command = new Command("the-command")
             {
                 option
             };
 
             var result = command.Parse("the-command");
 
-            result.ValueForOption("-x")
+            result.ValueForOption(option)
                   .Should()
                   .BeAssignableTo<IReadOnlyCollection<string>>()
                   .Which
@@ -272,14 +275,15 @@ 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>()
@@ -292,27 +296,29 @@ 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" });
         }
@@ -323,18 +329,19 @@ 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" });
         }
@@ -361,14 +368,15 @@ public void The_default_value_of_an_option_with_no_arguments_is_null()
         [Fact]
         public void By_default_an_option_without_arguments_parses_as_false_when_it_is_not_applied()
         {
+            var option = new Option("-x");
             var command = new Command("something")
             {
-                new Option("-x")
+                option
             };
 
             var result = command.Parse("something");
 
-            result.ValueForOption<bool>("-x")
+            result.ValueForOption<bool>(option)
                   .Should()
                   .BeFalse();
         }
@@ -439,7 +447,7 @@ 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);
         }
@@ -464,14 +472,15 @@ public void An_option_argument_with_a_default_argument_can_be_converted_to_the_r
         [Fact]
         public void Specifying_an_option_argument_overrides_the_default_value()
         {
+            var option = new Option<int>("-x", () => 123);
             var command = new Command("something")
             {
-                new Option<int>("-x", () => 123)
+                option
             };
 
             var result = command.Parse("something -x 456");
 
-            var value = result.ValueForOption<int>("-x");
+            var value = result.ValueForOption(option);
 
             value.Should().Be(456);
         }
@@ -491,7 +500,7 @@ public void Values_can_be_correctly_converted_to_nullable_int_with_no_value_with
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
 
-            var value = option.Parse("").ValueForOption<int?>("-x");
+            var value = option.Parse("").ValueForOption<int?>(option);
 
             value.Should().BeNull();
         }
@@ -521,7 +530,7 @@ public void Values_can_be_correctly_converted_to_double_without_the_parser_speci
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
 
-            var value = option.Parse("-x 123.456").ValueForOption<double>("-x");
+            var value = option.Parse("-x 123.456").ValueForOption<double>(option);
 
             value.Should().Be(123.456d);
         }
@@ -531,7 +540,7 @@ public void Values_can_be_correctly_converted_to_float_without_the_parser_specif
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
 
-            var value = option.Parse("-x 123.456").ValueForOption<float>("-x");
+            var value = option.Parse("-x 123.456").ValueForOption<float>(option);
 
             value.Should().Be(123.456f);
         }
@@ -541,24 +550,24 @@ public void Options_with_no_arguments_specified_can_be_correctly_converted_to_bo
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
 
-            option.Parse("-x").ValueForOption<bool>("-x").Should().BeTrue();
+            option.Parse("-x").ValueForOption<bool>(option).Should().BeTrue();
         }
 
         [Fact]
         public void Options_with_arguments_specified_can_be_correctly_converted_to_bool_without_the_parser_specifying_a_custom_converter()
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrOne);
 
-            option.Parse("-x false").ValueForOption<bool>("-x").Should().BeFalse();
-            option.Parse("-x true").ValueForOption<bool>("-x").Should().BeTrue();
+            option.Parse("-x false").ValueForOption<bool>(option).Should().BeFalse();
+            option.Parse("-x true").ValueForOption<bool>(option).Should().BeTrue();
         }
 
         [Fact]
         public void Values_can_be_correctly_converted_to_array_of_int_without_the_parser_specifying_a_custom_converter()
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrMore);
 
-            var value = option.Parse("-x 1 -x 2 -x 3").ValueForOption<int[]>("-x");
+            var value = option.Parse("-x 1 -x 2 -x 3").ValueForOption<int[]>(option);
 
             value.Should().BeEquivalentTo(1, 2, 3);
         }
@@ -608,7 +617,7 @@ public void Values_can_be_correctly_converted_to_List_of_int_without_the_parser_
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrMore);
 
-            var value = option.Parse("-x 1 -x 2 -x 3").ValueForOption<List<int>>("-x");
+            var value = option.Parse("-x 1 -x 2 -x 3").ValueForOption<List<int>>(option);
 
             value.Should().BeEquivalentTo(1, 2, 3);
         }
@@ -618,7 +627,7 @@ public void Values_can_be_correctly_converted_to_IEnumerable_of_int_without_the_
         {
             var option = new Option("-x", arity: ArgumentArity.ZeroOrMore);
 
-            var value = option.Parse("-x 1 -x 2 -x 3").ValueForOption<IEnumerable<int>>("-x");
+            var value = option.Parse("-x 1 -x 2 -x 3").ValueForOption<IEnumerable<int>>(option);
 
             value.Should().BeEquivalentTo(1, 2, 3);
         }
@@ -630,7 +639,7 @@ public void Enum_values_can_be_correctly_converted_based_on_enum_value_name_with
 
             var parseResult = option.Parse("-x Monday");
 
-            var value = parseResult.ValueForOption<DayOfWeek>("-x");
+            var value = parseResult.ValueForOption<DayOfWeek>(option);
 
             value.Should().Be(DayOfWeek.Monday);
         }
@@ -655,7 +664,7 @@ public void When_getting_values_and_specifying_a_conversion_type_that_is_not_sup
 
             var result = option.Parse("-x not-an-int");
 
-            Action getValue = () => result.ValueForOption<int>("-x");
+            Action getValue = () => result.ValueForOption<int>(option);
 
             getValue.Should()
                     .Throw<InvalidOperationException>()
@@ -672,7 +681,7 @@ public void When_getting_an_array_of_values_and_specifying_a_conversion_type_tha
 
             var result = option.Parse("-x not-an-int -x 2");
 
-            Action getValue = () => result.ValueForOption<int[]>("-x");
+            Action getValue = () => result.ValueForOption<int[]>(option);
 
             getValue.Should()
                     .Throw<InvalidOperationException>()

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

@@ -260,15 +260,16 @@ 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 +308,16 @@ 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);
         }