small change to arg forwarding methods, test fixes

src/dotnet/ArgumentForwardingExtensions.cs

@@ -7,11 +7,14 @@ namespace Microsoft.DotNet.Cli
 {
     public static class ArgumentForwardingExtensions
     {
+        public static ArgumentsRule Forward(
+            this ArgumentsRule rule) =>
+            rule.MaterializeAs(o => new ForwardedArgument(o.Arguments.SingleOrDefault()));
+
         public static ArgumentsRule ForwardAs(
             this ArgumentsRule rule,
             string template) =>
-            rule.MaterializeAs(o =>
+            rule.MaterializeAs(o => new ForwardedArgument(template));
-                new ForwardedArgument(string.Format(template, o.Arguments.Single())));
 
         public static ArgumentsRule ForwardAs(
             this ArgumentsRule rule,

src/dotnet/CommonOptions.cs

@@ -1,4 +1,5 @@
 using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Tools.Common;
 
@@ -22,7 +23,7 @@ namespace Microsoft.DotNet.Cli
                           "m", "minimal",
                           "n", "normal",
                           "d", "detailed")
-                      .ForwardAs("/verbosity:{0}"));
+                      .ForwardAs(o => $"/verbosity:{o.Arguments.Single()}"));
 
         public static ArgumentsRule DefaultToCurrentDirectory(this ArgumentsRule rule) =>
             rule.With(defaultValue: () => PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory()));

src/dotnet/commands/dotnet-build/BuildCommandParser.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Linq;
 using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli
@@ -12,37 +13,37 @@ namespace Microsoft.DotNet.Cli
                 "build",
                 ".NET Builder",
                 Accept.ZeroOrOneArgument
-                      .ForwardAs("{0}"),
+                      .Forward(),
                 CommonOptions.HelpOption(),
                 Create.Option(
                     "-o|--output",
                     "Output directory in which to place built artifacts.",
                     Accept.ExactlyOneArgument
                           .With(name: "OUTPUT_DIR")
-                          .ForwardAs("/p:OutputPath={0}")),
+                          .ForwardAs(o => $"/p:OutputPath={o.Arguments.Single()}")),
                 Create.Option(
                     "-f|--framework",
                     "Target framework to build for. The target framework has to be specified in the project file.",
                     Accept.AnyOneOf(Suggest.TargetFrameworksFromProjectFile)
-                          .ForwardAs("/p:TargetFramework={0}")),
+                          .ForwardAs(o => $"/p:TargetFramework={o.Arguments.Single()}")),
                 Create.Option(
                     "-r|--runtime",
                     "Target runtime to build for. The default is to build a portable application.",
                     Accept.AnyOneOf(Suggest.RunTimesFromProjectFile)
-                          .ForwardAs("/p:RuntimeIdentifier={0}")),
+                          .ForwardAs(o => $"/p:RuntimeIdentifier={o.Arguments.Single()}")),
                 Create.Option(
                     "-c|--configuration",
                     "Configuration to use for building the project. Default for most projects is  \"Debug\".",
                     Accept.ExactlyOneArgument
                           .With(name: "CONFIGURATION")
                           .WithSuggestionsFrom("DEBUG", "RELEASE")
-                          .ForwardAs("/p:Configuration={0}")),
+                          .ForwardAs(o => $"/p:Configuration={o.Arguments.Single()}")),
                 Create.Option(
                     "--version-suffix",
                     "Defines the value for the $(VersionSuffix) property in the project",
                     Accept.ExactlyOneArgument
                           .With(name: "VERSION_SUFFIX")
-                          .ForwardAs("/p:VersionSuffix={0}")),
+                          .ForwardAs(o => $"/p:VersionSuffix={o.Arguments.Single()}")),
                 Create.Option(
                     "--no-incremental",
                     "Disables incremental build."),

src/dotnet/commands/dotnet-complete/CompleteCommand.cs

@@ -24,7 +24,7 @@ namespace Microsoft.DotNet.Cli
                 // parse the arguments
                 var result = parser.ParseFrom("dotnet complete", args);
 
-                var complete = result["complete"];
+                var complete = result["dotnet"]["complete"];
 
                 var suggestions = Suggestions(complete);
 

src/dotnet/commands/dotnet-complete/CompleteCommandParser.cs

@@ -15,7 +15,6 @@ namespace Microsoft.DotNet.Cli
                       .With(name: "path"),
                 Create.Option("--position", "",
                               Accept.ExactlyOneArgument
-                                    .With(name: "command")
+                                    .With(name: "command")));
-                                    .MaterializeAs(o => int.Parse(o.Arguments.Single()))));
     }
 }

src/dotnet/commands/dotnet-publish/PublishCommandParser.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Linq;
 using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli
@@ -8,38 +9,39 @@ namespace Microsoft.DotNet.Cli
     internal static class PublishCommandParser
     {
         public static Command Publish() =>
-            Create.Command("publish",
+            Create.Command(
-                           ".NET Publisher",
+                "publish",
-                           Accept.ZeroOrMoreArguments,
+                ".NET Publisher",
-                           CommonOptions.HelpOption(),
+                Accept.ZeroOrMoreArguments,
-                           Create.Option("-f|--framework",
+                CommonOptions.HelpOption(),
-                                         "Target framework to publish for. The target framework has to be specified in the project file.",
+                Create.Option("-f|--framework",
-                                         Accept.WithSuggestionsFrom(_ => Suggest.TargetFrameworksFromProjectFile())
+                              "Target framework to publish for. The target framework has to be specified in the project file.",
-                                               .With(name: "FRAMEWORK")
+                              Accept.WithSuggestionsFrom(_ => Suggest.TargetFrameworksFromProjectFile())
-                                               .ForwardAs("/p:TargetFramework={0}")),
+                                    .With(name: "FRAMEWORK")
-                           Create.Option("-r|--runtime",
+                                    .ForwardAs(o => $"/p:TargetFramework={o.Arguments.Single()}")),
-                                         "Publish the project for a given runtime. This is used when creating self-contained deployment. Default is to publish a framework-dependent app.",
+                Create.Option("-r|--runtime",
-                                         Accept.WithSuggestionsFrom(_ => Suggest.RunTimesFromProjectFile())
+                              "Publish the project for a given runtime. This is used when creating self-contained deployment. Default is to publish a framework-dependent app.",
-                                               .With(name: "RUNTIME_IDENTIFIER")
+                              Accept.WithSuggestionsFrom(_ => Suggest.RunTimesFromProjectFile())
-                                               .ForwardAs("/p:RuntimeIdentifier={0}")),
+                                    .With(name: "RUNTIME_IDENTIFIER")
-                           Create.Option("-o|--output",
+                                    .ForwardAs(o => $"/p:RuntimeIdentifier={o.Arguments.Single()}")),
-                                         "Output directory in which to place the published artifacts.",
+                Create.Option("-o|--output",
-                                         Accept.ExactlyOneArgument
+                              "Output directory in which to place the published artifacts.",
-                                               .With(name: "OUTPUT_DIR")
+                              Accept.ExactlyOneArgument
-                                               .ForwardAs("/p:PublishDir={0}")),
+                                    .With(name: "OUTPUT_DIR")
-                           Create.Option("-c|--configuration", "Configuration to use for building the project.  Default for most projects is  \"Debug\".",
+                                    .ForwardAs(o => $"/p:PublishDir={o.Arguments.Single()}")),
-                                         Accept.ExactlyOneArgument
+                Create.Option("-c|--configuration", "Configuration to use for building the project.  Default for most projects is  \"Debug\".",
-                                               .With(name: "CONFIGURATION")
+                              Accept.ExactlyOneArgument
-                                               .WithSuggestionsFrom("DEBUG", "RELEASE")
+                                    .With(name: "CONFIGURATION")
-                                               .ForwardAs("/p:Configuration={0}")),
+                                    .WithSuggestionsFrom("DEBUG", "RELEASE")
-                           Create.Option("--version-suffix", "Defines the value for the $(VersionSuffix) property in the project.",
+                                    .ForwardAs(o => $"/p:Configuration={o.Arguments.Single()}")),
-                                         Accept.ExactlyOneArgument
+                Create.Option("--version-suffix", "Defines the value for the $(VersionSuffix) property in the project.",
-                                               .With(name: "VERSION_SUFFIX")
+                              Accept.ExactlyOneArgument
-                                               .ForwardAs("/p:VersionSuffix={0}")),
+                                    .With(name: "VERSION_SUFFIX")
-                           Create.Option("--filter", "The XML file that contains the list of packages to be excluded from publish step.",
+                                    .ForwardAs(o => $"/p:VersionSuffix={o.Arguments.Single()}")),
-                                         Accept.ExactlyOneArgument
+                Create.Option("--filter", "The XML file that contains the list of packages to be excluded from publish step.",
-                                               .With(name: "PROFILE_XML")
+                              Accept.ExactlyOneArgument
-                                               .ForwardAs("/p:FilterProjectFiles={0}")),
+                                    .With(name: "PROFILE_XML")
-                           CommonOptions.VerbosityOption());
+                                    .ForwardAs(o => $"/p:FilterProjectFiles={o.Arguments.Single()}")),
+                CommonOptions.VerbosityOption());
     }
 }

src/dotnet/commands/dotnet-restore/RestoreCommandParser.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Linq;
 using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli
@@ -31,7 +32,7 @@ namespace Microsoft.DotNet.Cli
                     "Directory to install packages in.",
                     Accept.ExactlyOneArgument
                           .With(name: "PACKAGES_DIRECTORY")
-                          .ForwardAs("/p:RestorePackagesPath={0}")),
+                          .ForwardAs(o => $"/p:RestorePackagesPath={o.Arguments.Single()}")),
                 Create.Option(
                     "--disable-parallel",
                     "Disables restoring multiple projects in parallel.",
@@ -42,7 +43,7 @@ namespace Microsoft.DotNet.Cli
                     "The NuGet configuration file to use.",
                     Accept.ExactlyOneArgument
                           .With(name: "FILE")
-                          .ForwardAs("/p:RestoreConfigFile={0}")),
+                          .ForwardAs(o => $"/p:RestoreConfigFile={o.Arguments.Single()}")),
                 Create.Option(
                     "--no-cache",
                     "Do not cache packages and http requests.",

test/dotnet-msbuild.Tests/GivenDotnetRestoreInvocation.cs

@@ -26,8 +26,8 @@ namespace Microsoft.DotNet.Cli.MSBuild.Tests
         [InlineData(new string[] { "--no-cache" }, "/p:RestoreNoCache=true")]
         [InlineData(new string[] { "--ignore-failed-sources" }, "/p:RestoreIgnoreFailedSources=true")]
         [InlineData(new string[] { "--no-dependencies" }, "/p:RestoreRecursive=false")]
-        [InlineData(new string[] { "-v", "<verbosity>" }, @"/verbosity:<verbosity>")]
+        [InlineData(new string[] { "-v", "minimal" }, @"/verbosity:minimal")]
-        [InlineData(new string[] { "--verbosity", "<verbosity>" }, @"/verbosity:<verbosity>")]
+        [InlineData(new string[] { "--verbosity", "minimal" }, @"/verbosity:minimal")]
         public void MsbuildInvocationIsCorrect(string[] args, string expectedAdditionalArgs)
         {
             expectedAdditionalArgs = (string.IsNullOrEmpty(expectedAdditionalArgs) ? "" : $" {expectedAdditionalArgs}");

test/dotnet.Tests/ParserTests/ArgumentForwardingExtensionsTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using FluentAssertions;
+using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Xunit;
@@ -13,28 +14,31 @@ namespace Microsoft.DotNet.Tests.ParserTests
     public class ArgumentForwardingExtensionsTests
     {
         [Fact]
-        public void An_outgoing_command_line_can_be_generated_based_on_a_parse_result()
+        public void AnOutgoingCommandLineCanBeGeneratedBasedOnAParseResult()
         {
             var command = Command("the-command", "",
-                Option("-o|--one", "",
+                                  Option("-o|--one", "",
-                    ZeroOrOneArgument.ForwardAs("/i:{0}")),
+                                         ZeroOrOneArgument
-                Option("-t|--two", "",
+                                             .ForwardAs(o => $"/i:{o.Arguments.Single()}")),
-                    ZeroOrOneArgument.ForwardAs("/s:{0}")));
+                                  Option("-t|--two", "",
+                                         NoArguments
+                                             .ForwardAs("/s:true")));
 
-            var result = command.Parse("the-command -t argument-two-value -o 123");
+            var result = command.Parse("the-command -t -o 123");
 
             result["the-command"]
                 .OptionValuesToBeForwarded()
                 .Should()
-                .BeEquivalentTo("/i:123", "/s:argument-two-value");
+                .BeEquivalentTo("/i:123", "/s:true");
         }
 
         [Fact]
         public void MultipleArgumentsCanBeJoinedWhenForwarding()
         {
             var command = Command("the-command", "",
-                Option("-x", "",
+                                  Option("-x", "",
-                    ZeroOrMoreArguments.ForwardAs(o => $"/x:{string.Join("&", o.Arguments)}")));
+                                         ZeroOrMoreArguments
+                                             .ForwardAs(o => $"/x:{string.Join("&", o.Arguments)}")));
 
             var result = command.Parse("the-command -x one -x two");
 
@@ -43,5 +47,21 @@ namespace Microsoft.DotNet.Tests.ParserTests
                 .Should()
                 .BeEquivalentTo("/x:one&two");
         }
+
+        [Fact]
+        public void AnArgumentCanBeForwardedAsIs()
+        {
+            var command = Command("the-command", "",
+                                  Option("-x", "",
+                                         ZeroOrMoreArguments
+                                             .Forward()));
+
+            var result = command.Parse("the-command -x one");
+
+            result["the-command"]
+                .OptionValuesToBeForwarded()
+                .Should()
+                .BeEquivalentTo("one");
+        }
     }
 }

test/dotnet.Tests/ParserTests/RestoreParserTests.cs

@@ -22,13 +22,13 @@ namespace Microsoft.DotNet.Tests.ParserTests
         [Fact]
         public void RestoreCapturesArgumentsToForwardToMSBuildWhenTargetIsSpecified()
         {
-            var parser = Parser.Instance["dotnet"]["restore"];
+            var parser = Parser.Instance;
 
-            var result = parser.Parse(@".\some.csproj --packages c:\.nuget\packages /p:SkipInvalidConfigurations=true");
+            var result = parser.Parse(@"dotnet restore .\some.csproj --packages c:\.nuget\packages /p:SkipInvalidConfigurations=true");
 
             output.WriteLine(result.Diagram());
 
-            result["restore"]
+            result["dotnet"]["restore"]
                 .Arguments
                 .Should()
                 .BeEquivalentTo(@".\some.csproj", @"/p:SkipInvalidConfigurations=true");
@@ -37,13 +37,13 @@ namespace Microsoft.DotNet.Tests.ParserTests
         [Fact]
         public void RestoreCapturesArgumentsToForwardToMSBuildWhenTargetIsNotSpecified()
         {
-            var parser = Parser.Instance["dotnet"]["restore"];
+            var parser = Parser.Instance;
 
-            var result = parser.Parse(@"--packages c:\.nuget\packages /p:SkipInvalidConfigurations=true");
+            var result = parser.Parse(@"dotnet restore --packages c:\.nuget\packages /p:SkipInvalidConfigurations=true");
 
             output.WriteLine(result.Diagram());
 
-            result["restore"]
+            result["dotnet"]["restore"]
                 .Arguments
                 .Should()
                 .BeEquivalentTo(@"/p:SkipInvalidConfigurations=true");