Merge pull request #2431 from KathleenDollard/powderhouse-kad-removed-fluent-returns

KathleenDollard · web-flow · commit 9395d84ec896 · 2024-06-11T13:31:40.000-04:00
Powderhouse removed CliExit and fluent style for pipeline execution
diff --git a/src/System.CommandLine.Subsystems.Tests/AlternateSubsystems.cs b/src/System.CommandLine.Subsystems.Tests/AlternateSubsystems.cs
@@ -10,11 +10,10 @@ internal class AlternateSubsystems
     {
         internal class AlternateVersion : VersionSubsystem
         {
-            protected override CliExit Execute(PipelineResult pipelineResult)
+            protected override void Execute(PipelineResult pipelineResult)
             {
                 pipelineResult.ConsoleHack.WriteLine($"***{CliExecutable.ExecutableVersion}***");
-                pipelineResult.AlreadyHandled = true;
-                return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+                pipelineResult.SetSuccess();
             }
         }
 
@@ -29,12 +28,12 @@ public VersionThatUsesHelpData(CliSymbol symbol)
 
             private CliSymbol Symbol { get; }
 
-            protected override CliExit Execute(PipelineResult pipelineResult)
+            protected override void Execute(PipelineResult pipelineResult)
             {
                 TryGetAnnotation(Symbol, HelpAnnotations.Description, out string? description);
                 pipelineResult.ConsoleHack.WriteLine(description);
                 pipelineResult.AlreadyHandled = true;
-                return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+                pipelineResult.SetSuccess();
             }
         }
 
@@ -44,23 +43,23 @@ internal class VersionWithInitializeAndTeardown : VersionSubsystem
             internal bool ExecutionWasRun;
             internal bool TeardownWasRun;
 
-            protected override CliConfiguration Initialize(InitializationContext context)
+            protected override void Initialize(InitializationContext context)
             {
+                base.Initialize(context);
                 // marker hack needed because ConsoleHack not available in initialization
                 InitializationWasRun = true;
-                return base.Initialize(context);
             }
 
-            protected override CliExit Execute(PipelineResult pipelineResult)
+            protected override void Execute(PipelineResult pipelineResult)
             {
                 ExecutionWasRun = true;
-                return base.Execute(pipelineResult);
+                base.Execute(pipelineResult);
             }
 
-            protected override CliExit TearDown(CliExit cliExit)
+            protected override void TearDown(PipelineResult pipelineResult)
             {
                 TeardownWasRun = true;
-                return base.TearDown(cliExit);
+                base.TearDown(pipelineResult);
             }
         }
 
diff --git a/src/System.CommandLine.Subsystems.Tests/PipelineTests.cs b/src/System.CommandLine.Subsystems.Tests/PipelineTests.cs
@@ -43,7 +43,7 @@ public void Subsystem_runs_in_pipeline_only_when_requested(string input, bool sh
             var exit = pipeline.Execute(GetNewTestConfiguration(), input, console);
 
             exit.ExitCode.Should().Be(0);
-            exit.Handled.Should().Be(shouldRun);
+            exit.AlreadyHandled.Should().Be(shouldRun);
             if (shouldRun)
             {
                 console.GetBuffer().Trim().Should().Be(TestData.AssemblyVersionString);
@@ -61,7 +61,7 @@ public void Subsystem_runs_with_explicit_parse_only_when_requested(string input,
             var exit = pipeline.Execute(result, input, console);
 
             exit.ExitCode.Should().Be(0);
-            exit.Handled.Should().Be(shouldRun);
+            exit.AlreadyHandled.Should().Be(shouldRun);
             if (shouldRun)
             {
                 console.GetBuffer().Trim().Should().Be(TestData.AssemblyVersionString);
@@ -79,7 +79,7 @@ public void Subsystem_runs_initialize_and_teardown_when_requested(string input,
             var exit = pipeline.Execute(GetNewTestConfiguration(), input, console);
 
             exit.ExitCode.Should().Be(0);
-            exit.Handled.Should().Be(shouldRun);
+            exit.AlreadyHandled.Should().Be(shouldRun);
             versionSubsystem.InitializationWasRun.Should().BeTrue();
             versionSubsystem.ExecutionWasRun.Should().Be(shouldRun);
             versionSubsystem.TeardownWasRun.Should().BeTrue();
@@ -109,7 +109,7 @@ public void Subsystem_works_without_pipeline(string input, bool shouldRun)
                 var exit = Subsystem.Execute(versionSubsystem, parseResult, input, console);
                 exit.Should().NotBeNull();
                 exit.ExitCode.Should().Be(0);
-                exit.Handled.Should().BeTrue();
+                exit.AlreadyHandled.Should().BeTrue();
                 console.GetBuffer().Trim().Should().Be(TestData.AssemblyVersionString);
             }
         }
@@ -132,7 +132,7 @@ public void Subsystem_works_without_pipeline_style2(string input, bool shouldRun
             var exit = Subsystem.ExecuteIfNeeded(versionSubsystem, parseResult, input, console);
 
             exit.ExitCode.Should().Be(0);
-            exit.Handled.Should().Be(shouldRun);
+            exit.AlreadyHandled.Should().Be(shouldRun);
             console.GetBuffer().Trim().Should().Be(expectedVersion);
         }
 
diff --git a/src/System.CommandLine.Subsystems.Tests/VersionFunctionalTests.cs b/src/System.CommandLine.Subsystems.Tests/VersionFunctionalTests.cs
@@ -26,7 +26,7 @@ public void When_the_version_option_is_specified_then_the_version_is_written_to_
             var exit = pipeline.Execute(configuration, "-v", consoleHack);
 
             exit.ExitCode.Should().Be(0);
-            exit.Handled.Should().BeTrue();
+            exit.AlreadyHandled.Should().BeTrue();
             consoleHack.GetBuffer().Should().Be($"{version}{newLine}");
         }
 
diff --git a/src/System.CommandLine.Subsystems/CliExit.cs b/src/System.CommandLine.Subsystems/CliExit.cs
diff --git a/src/System.CommandLine.Subsystems/CompletionSubsystem.cs b/src/System.CommandLine.Subsystems/CompletionSubsystem.cs
@@ -18,9 +18,9 @@ protected internal override bool GetIsActivated(ParseResult? parseResult)
             ? false
             : false;
 
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override void Execute(PipelineResult pipelineResult)
     {
         pipelineResult.ConsoleHack.WriteLine("Not yet implemented");
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
     }
 }
diff --git a/src/System.CommandLine.Subsystems/Directives/DiagramSubsystem.cs b/src/System.CommandLine.Subsystems/Directives/DiagramSubsystem.cs
@@ -13,14 +13,14 @@ public class DiagramSubsystem( IAnnotationProvider? annotationProvider = null)
     //protected internal override bool GetIsActivated(ParseResult? parseResult)
     //   => parseResult is not null && option is not null && parseResult.GetValue(option);
 
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override void Execute(PipelineResult pipelineResult)
     {
         // Gather locations
         //var locations = pipelineResult.ParseResult.LocationMap
         //                   .Concat(Map(pipelineResult.ParseResult.Configuration.PreProcessedLocations));
 
         pipelineResult.ConsoleHack.WriteLine("Output diagram");
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
     }
 
 
diff --git a/src/System.CommandLine.Subsystems/Directives/DirectiveSubsystem.cs b/src/System.CommandLine.Subsystems/Directives/DirectiveSubsystem.cs
@@ -19,7 +19,7 @@ public DirectiveSubsystem(string name, SubsystemKind kind, IAnnotationProvider?
         Id = id ?? name;
     }
 
-    protected internal override CliConfiguration Initialize(InitializationContext context)
+    protected internal override void Initialize(InitializationContext context)
     {
         for (int i = 0; i < context.Args.Count; i++)
         {
@@ -50,8 +50,6 @@ protected internal override CliConfiguration Initialize(InitializationContext co
                 break;
             }
         }
-
-        return context.Configuration;
     }
 
     protected internal override bool GetIsActivated(ParseResult? parseResult)
diff --git a/src/System.CommandLine.Subsystems/Directives/ResponseSubsystem.cs b/src/System.CommandLine.Subsystems/Directives/ResponseSubsystem.cs
@@ -9,11 +9,8 @@ namespace System.CommandLine.Directives;
 public class ResponseSubsystem()
     : CliSubsystem("Response", SubsystemKind.Response, null)
 {
-    protected internal override CliConfiguration Initialize(InitializationContext context)
-    {
-        context.Configuration.ResponseFileTokenReplacer = Replacer;
-        return context.Configuration;
-    }
+    protected internal override void Initialize(InitializationContext context) 
+        => context.Configuration.ResponseFileTokenReplacer = Replacer;
 
     public static (List<string>? tokens, List<string>? errors) Replacer(string responseSourceName)
     {
diff --git a/src/System.CommandLine.Subsystems/ErrorReportingSubsystem.cs b/src/System.CommandLine.Subsystems/ErrorReportingSubsystem.cs
@@ -23,14 +23,14 @@ protected internal override bool GetIsActivated(ParseResult? parseResult)
         => parseResult is not null && parseResult.Errors.Any();
 
     // TODO: properly test execute directly when parse result is usable in tests
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override void Execute(PipelineResult pipelineResult)
     {
         var _ = pipelineResult.ParseResult
             ?? throw new ArgumentException("The parse result has not been set", nameof(pipelineResult));
 
         Report(pipelineResult.ConsoleHack, pipelineResult.ParseResult.Errors);
 
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
     }
 
     public void Report(ConsoleHack consoleHack, IReadOnlyList<ParseError> errors)
diff --git a/src/System.CommandLine.Subsystems/HelpSubsystem.cs b/src/System.CommandLine.Subsystems/HelpSubsystem.cs
@@ -24,21 +24,17 @@ public class HelpSubsystem(IAnnotationProvider? annotationProvider = null)
         Arity = ArgumentArity.Zero
     };
 
-    protected internal override CliConfiguration Initialize(InitializationContext context)
-    {
-        context.Configuration.RootCommand.Add(HelpOption);
-
-        return context.Configuration;
-    }
+    protected internal override void Initialize(InitializationContext context) 
+        => context.Configuration.RootCommand.Add(HelpOption);
 
     protected internal override bool GetIsActivated(ParseResult? parseResult)
         => parseResult is not null && parseResult.GetValue(HelpOption);
 
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override void Execute(PipelineResult pipelineResult)
     {
         // TODO: Match testable output pattern
         pipelineResult.ConsoleHack.WriteLine("Help me!");
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
     }
 
     public bool TryGetDescription (CliSymbol symbol, out string? description)
diff --git a/src/System.CommandLine.Subsystems/Pipeline.cs b/src/System.CommandLine.Subsystems/Pipeline.cs
@@ -51,20 +51,21 @@ public ParseResult Parse(CliConfiguration configuration, IReadOnlyList<string> a
         return parseResult;
     }
 
-    public CliExit Execute(CliConfiguration configuration, string rawInput, ConsoleHack? consoleHack = null)
+    public PipelineResult Execute(CliConfiguration configuration, string rawInput, ConsoleHack? consoleHack = null)
         => Execute(configuration, CliParser.SplitCommandLine(rawInput).ToArray(), rawInput, consoleHack);
 
-    public CliExit Execute(CliConfiguration configuration, string[] args, string rawInput, ConsoleHack? consoleHack = null)
+    public PipelineResult Execute(CliConfiguration configuration, string[] args, string rawInput, ConsoleHack? consoleHack = null)
     {
-        var cliExit = Execute(Parse(configuration, args), rawInput, consoleHack);
-        return TearDownSubsystems(cliExit);
+        var pipelineResult = Execute(Parse(configuration, args), rawInput, consoleHack);
+        TearDownSubsystems(pipelineResult);
+        return pipelineResult;
     }
 
-    public CliExit Execute(ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)
+    public PipelineResult Execute(ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)
     {
         var pipelineResult = new PipelineResult(parseResult, rawInput, this, consoleHack ?? new ConsoleHack());
         ExecuteSubsystems(pipelineResult);
-        return new CliExit(pipelineResult);
+        return pipelineResult;
     }
 
     // TODO: Consider whether this should be public. It would simplify testing, but would it do anything else
@@ -95,18 +96,17 @@ protected virtual void InitializeSubsystems(InitializationContext context)
     /// Perform any cleanup operations
     /// </summary>
     /// <param name="pipelineResult">The context of the current execution</param>
-    protected virtual CliExit TearDownSubsystems(CliExit cliExit)
+    protected virtual void TearDownSubsystems(PipelineResult pipelineResult)
     {
-        // TODO: Work on this design as the last cliExit wins and they may not all be well behaved
+        // TODO: Work on this design as the last pipelineResult wins and they may not all be well behaved
         var subsystems = Subsystems.Reverse();
         foreach (var subsystem in subsystems)
         {
             if (subsystem is not null)
             {
-                cliExit = subsystem.TearDown(cliExit);
+                subsystem.TearDown(pipelineResult);
             }
         }
-        return cliExit;
     }
 
     protected virtual void ExecuteSubsystems(PipelineResult pipelineResult)
@@ -117,7 +117,7 @@ protected virtual void ExecuteSubsystems(PipelineResult pipelineResult)
         {
             if (subsystem is not null)
             {
-                pipelineResult = subsystem.ExecuteIfNeeded(pipelineResult);
+                subsystem.ExecuteIfNeeded(pipelineResult);
             }
         }
     }
diff --git a/src/System.CommandLine.Subsystems/Subsystems/CliSubsystem.cs b/src/System.CommandLine.Subsystems/Subsystems/CliSubsystem.cs
@@ -66,9 +66,9 @@ protected internal bool TryGetAnnotation<TValue>(CliSymbol symbol, AnnotationId<
     /// Executes the behavior of the subsystem. For example, help would write information to the console.
     /// </summary>
     /// <param name="pipelineResult">The context contains data like the ParseResult, and allows setting of values like whether execution was handled and the CLI should terminate </param>
-    /// <returns>A CliExit object with information such as whether the CLI should terminate</returns>
-    protected internal virtual CliExit Execute(PipelineResult pipelineResult)
-        => CliExit.NotRun(pipelineResult.ParseResult);
+    /// <returns>A PipelineResult object with information such as whether the CLI should terminate</returns>
+    protected internal virtual void Execute(PipelineResult pipelineResult) 
+        => pipelineResult.NotRun(pipelineResult.ParseResult);
 
     internal PipelineResult ExecuteIfNeeded(PipelineResult pipelineResult)
         => ExecuteIfNeeded(pipelineResult.ParseResult, pipelineResult);
@@ -107,11 +107,11 @@ internal PipelineResult ExecuteIfNeeded(ParseResult? parseResult, PipelineResult
     /// <returns>True if parsing should continue</returns> // there might be a better design that supports a message
     // TODO: Because of this and similar usage, consider combining CLI declaration and config. ArgParse calls this the parser, which I like
     // TODO: Why does Intitialize return a configuration?
-    protected internal virtual CliConfiguration Initialize(InitializationContext context)
-        => context.Configuration;
+    protected internal virtual void Initialize(InitializationContext context)
+    {}
 
     // TODO: Determine if this is needed.
-    protected internal virtual CliExit TearDown(CliExit cliExit)
-        => cliExit;
+    protected internal virtual void TearDown(PipelineResult pipelineResult)
+    {}
 
 }
diff --git a/src/System.CommandLine.Subsystems/Subsystems/PipelineResult.cs b/src/System.CommandLine.Subsystems/Subsystems/PipelineResult.cs
@@ -1,6 +1,8 @@
 ﻿// 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.
 
+
+
 namespace System.CommandLine.Subsystems;
 
 public class PipelineResult(ParseResult? parseResult, string rawInput, Pipeline? pipeline, ConsoleHack? consoleHack = null)
@@ -13,4 +15,14 @@ public class PipelineResult(ParseResult? parseResult, string rawInput, Pipeline?
     public bool AlreadyHandled { get; set; }
     public int ExitCode { get; set; }
 
+    public void NotRun(ParseResult? parseResult)
+    {
+        // no op because defaults are false and 0
+    }
+
+    public void SetSuccess()
+    {
+        AlreadyHandled = true;
+        ExitCode = 0;
+    }
 }
diff --git a/src/System.CommandLine.Subsystems/Subsystems/Subsystem.cs b/src/System.CommandLine.Subsystems/Subsystems/Subsystem.cs
diff --git a/src/System.CommandLine.Subsystems/ValueSubsystem.cs b/src/System.CommandLine.Subsystems/ValueSubsystem.cs
diff --git a/src/System.CommandLine.Subsystems/VersionSubsystem.cs b/src/System.CommandLine.Subsystems/VersionSubsystem.cs

Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,10 @@ internal class AlternateSubsystems`
`10`	`10`	`{`
`11`	`11`	`internal class AlternateVersion : VersionSubsystem`
`12`	`12`	`{`
`13`		`- protected override CliExit Execute(PipelineResult pipelineResult)`
	`13`	`+ protected override void Execute(PipelineResult pipelineResult)`
`14`	`14`	`{`
`15`	`15`	`pipelineResult.ConsoleHack.WriteLine($"*{CliExecutable.ExecutableVersion}*");`
`16`		`- pipelineResult.AlreadyHandled = true;`
`17`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`16`	`+ pipelineResult.SetSuccess();`
`18`	`17`	`}`
`19`	`18`	`}`
`20`	`19`
`@@ -29,12 +28,12 @@ public VersionThatUsesHelpData(CliSymbol symbol)`
`29`	`28`
`30`	`29`	`private CliSymbol Symbol { get; }`
`31`	`30`
`32`		`- protected override CliExit Execute(PipelineResult pipelineResult)`
	`31`	`+ protected override void Execute(PipelineResult pipelineResult)`
`33`	`32`	`{`
`34`	`33`	`TryGetAnnotation(Symbol, HelpAnnotations.Description, out string? description);`
`35`	`34`	`pipelineResult.ConsoleHack.WriteLine(description);`
`36`	`35`	`pipelineResult.AlreadyHandled = true;`
`37`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`36`	`+ pipelineResult.SetSuccess();`
`38`	`37`	`}`
`39`	`38`	`}`
`40`	`39`
`@@ -44,23 +43,23 @@ internal class VersionWithInitializeAndTeardown : VersionSubsystem`
`44`	`43`	`internal bool ExecutionWasRun;`
`45`	`44`	`internal bool TeardownWasRun;`
`46`	`45`
`47`		`- protected override CliConfiguration Initialize(InitializationContext context)`
	`46`	`+ protected override void Initialize(InitializationContext context)`
`48`	`47`	`{`
	`48`	`+ base.Initialize(context);`
`49`	`49`	`// marker hack needed because ConsoleHack not available in initialization`
`50`	`50`	`InitializationWasRun = true;`
`51`		`- return base.Initialize(context);`
`52`	`51`	`}`
`53`	`52`
`54`		`- protected override CliExit Execute(PipelineResult pipelineResult)`
	`53`	`+ protected override void Execute(PipelineResult pipelineResult)`
`55`	`54`	`{`
`56`	`55`	`ExecutionWasRun = true;`
`57`		`- return base.Execute(pipelineResult);`
	`56`	`+ base.Execute(pipelineResult);`
`58`	`57`	`}`
`59`	`58`
`60`		`- protected override CliExit TearDown(CliExit cliExit)`
	`59`	`+ protected override void TearDown(PipelineResult pipelineResult)`
`61`	`60`	`{`
`62`	`61`	`TeardownWasRun = true;`
`63`		`- return base.TearDown(cliExit);`
	`62`	`+ base.TearDown(pipelineResult);`
`64`	`63`	`}`
`65`	`64`	`}`
`66`	`65`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public void When_the_version_option_is_specified_then_the_version_is_written_to_`
`26`	`26`	`var exit = pipeline.Execute(configuration, "-v", consoleHack);`
`27`	`27`
`28`	`28`	`exit.ExitCode.Should().Be(0);`
`29`		`- exit.Handled.Should().BeTrue();`
	`29`	`+ exit.AlreadyHandled.Should().BeTrue();`
`30`	`30`	`consoleHack.GetBuffer().Should().Be($"{version}{newLine}");`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,9 @@ protected internal override bool GetIsActivated(ParseResult? parseResult)`
`18`	`18`	`? false`
`19`	`19`	`: false;`
`20`	`20`
`21`		`- protected internal override CliExit Execute(PipelineResult pipelineResult)`
	`21`	`+ protected internal override void Execute(PipelineResult pipelineResult)`
`22`	`22`	`{`
`23`	`23`	`pipelineResult.ConsoleHack.WriteLine("Not yet implemented");`
`24`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`24`	`+ pipelineResult.SetSuccess();`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,14 @@ public class DiagramSubsystem( IAnnotationProvider? annotationProvider = null)`
`13`	`13`	`//protected internal override bool GetIsActivated(ParseResult? parseResult)`
`14`	`14`	`// => parseResult is not null && option is not null && parseResult.GetValue(option);`
`15`	`15`
`16`		`- protected internal override CliExit Execute(PipelineResult pipelineResult)`
	`16`	`+ protected internal override void Execute(PipelineResult pipelineResult)`
`17`	`17`	`{`
`18`	`18`	`// Gather locations`
`19`	`19`	`//var locations = pipelineResult.ParseResult.LocationMap`
`20`	`20`	`// .Concat(Map(pipelineResult.ParseResult.Configuration.PreProcessedLocations));`
`21`	`21`
`22`	`22`	`pipelineResult.ConsoleHack.WriteLine("Output diagram");`
`23`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`23`	`+ pipelineResult.SetSuccess();`
`24`	`24`	`}`
`25`	`25`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public DirectiveSubsystem(string name, SubsystemKind kind, IAnnotationProvider?`
`19`	`19`	`Id = id ?? name;`
`20`	`20`	`}`
`21`	`21`
`22`		`- protected internal override CliConfiguration Initialize(InitializationContext context)`
	`22`	`+ protected internal override void Initialize(InitializationContext context)`
`23`	`23`	`{`
`24`	`24`	`for (int i = 0; i < context.Args.Count; i++)`
`25`	`25`	`{`
`@@ -50,8 +50,6 @@ protected internal override CliConfiguration Initialize(InitializationContext co`
`50`	`50`	`break;`
`51`	`51`	`}`
`52`	`52`	`}`
`53`		`-`
`54`		`- return context.Configuration;`
`55`	`53`	`}`
`56`	`54`
`57`	`55`	`protected internal override bool GetIsActivated(ParseResult? parseResult)`
Original file line number	Diff line number	Diff line change
`@@ -9,11 +9,8 @@ namespace System.CommandLine.Directives;`
`9`	`9`	`public class ResponseSubsystem()`
`10`	`10`	`: CliSubsystem("Response", SubsystemKind.Response, null)`
`11`	`11`	`{`
`12`		`- protected internal override CliConfiguration Initialize(InitializationContext context)`
`13`		`- {`
`14`		`- context.Configuration.ResponseFileTokenReplacer = Replacer;`
`15`		`- return context.Configuration;`
`16`		`- }`
	`12`	`+ protected internal override void Initialize(InitializationContext context)`
	`13`	`+ => context.Configuration.ResponseFileTokenReplacer = Replacer;`
`17`	`14`
`18`	`15`	`public static (List<string>? tokens, List<string>? errors) Replacer(string responseSourceName)`
`19`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,14 +23,14 @@ protected internal override bool GetIsActivated(ParseResult? parseResult)`
`23`	`23`	`=> parseResult is not null && parseResult.Errors.Any();`
`24`	`24`
`25`	`25`	`// TODO: properly test execute directly when parse result is usable in tests`
`26`		`- protected internal override CliExit Execute(PipelineResult pipelineResult)`
	`26`	`+ protected internal override void Execute(PipelineResult pipelineResult)`
`27`	`27`	`{`
`28`	`28`	`var _ = pipelineResult.ParseResult`
`29`	`29`	`?? throw new ArgumentException("The parse result has not been set", nameof(pipelineResult));`
`30`	`30`
`31`	`31`	`Report(pipelineResult.ConsoleHack, pipelineResult.ParseResult.Errors);`
`32`	`32`
`33`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`33`	`+ pipelineResult.SetSuccess();`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public void Report(ConsoleHack consoleHack, IReadOnlyList<ParseError> errors)`