Remove CliExit and add SetSuccess/NotRun

KathleenDollard · KathleenDollard · commit 4443107eff52 · 2024-05-26T21:08:10.000-04:00
The SetSuccess and NotRun methods are intended to abstract what those conditions mean from the actual properties that are set, probably making them private after discussio. I have more confidence in SetSuccess than NotRun
diff --git a/src/System.CommandLine.Subsystems.Tests/AlternateSubsystems.cs b/src/System.CommandLine.Subsystems.Tests/AlternateSubsystems.cs
@@ -10,11 +10,11 @@ internal class AlternateSubsystems
     {
         internal class AlternateVersion : VersionSubsystem
         {
-            protected override CliExit Execute(PipelineResult pipelineResult)
+            protected override PipelineResult Execute(PipelineResult pipelineResult)
             {
                 pipelineResult.ConsoleHack.WriteLine($"***{CliExecutable.ExecutableVersion}***");
-                pipelineResult.AlreadyHandled = true;
-                return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+                pipelineResult.SetSuccess();
+                return pipelineResult;
             }
         }
 
@@ -29,12 +29,13 @@ public VersionThatUsesHelpData(CliSymbol symbol)
 
             private CliSymbol Symbol { get; }
 
-            protected override CliExit Execute(PipelineResult pipelineResult)
+            protected override PipelineResult Execute(PipelineResult pipelineResult)
             {
                 TryGetAnnotation(Symbol, HelpAnnotations.Description, out string? description);
                 pipelineResult.ConsoleHack.WriteLine(description);
                 pipelineResult.AlreadyHandled = true;
-                return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+                pipelineResult.SetSuccess();
+                return pipelineResult;
             }
         }
 
@@ -51,16 +52,16 @@ protected override CliConfiguration Initialize(InitializationContext context)
                 return base.Initialize(context);
             }
 
-            protected override CliExit Execute(PipelineResult pipelineResult)
+            protected override PipelineResult Execute(PipelineResult pipelineResult)
             {
                 ExecutionWasRun = true;
                 return base.Execute(pipelineResult);
             }
 
-            protected override CliExit TearDown(CliExit cliExit)
+            protected override PipelineResult TearDown(PipelineResult pipelineResult)
             {
                 TeardownWasRun = true;
-                return base.TearDown(cliExit);
+                return 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,10 @@ protected internal override bool GetIsActivated(ParseResult? parseResult)
             ? false
             : false;
 
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override PipelineResult Execute(PipelineResult pipelineResult)
     {
         pipelineResult.ConsoleHack.WriteLine("Not yet implemented");
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
+        return pipelineResult;
     }
 }
diff --git a/src/System.CommandLine.Subsystems/Directives/DiagramSubsystem.cs b/src/System.CommandLine.Subsystems/Directives/DiagramSubsystem.cs
@@ -13,14 +13,15 @@ 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 PipelineResult 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();
+        return pipelineResult;
     }
 
 
diff --git a/src/System.CommandLine.Subsystems/ErrorReportingSubsystem.cs b/src/System.CommandLine.Subsystems/ErrorReportingSubsystem.cs
@@ -23,14 +23,15 @@ 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 PipelineResult 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();
+        return pipelineResult;
     }
 
     public void Report(ConsoleHack consoleHack, IReadOnlyList<ParseError> errors)
diff --git a/src/System.CommandLine.Subsystems/HelpSubsystem.cs b/src/System.CommandLine.Subsystems/HelpSubsystem.cs
@@ -34,11 +34,12 @@ protected internal override CliConfiguration Initialize(InitializationContext co
     protected internal override bool GetIsActivated(ParseResult? parseResult)
         => parseResult is not null && parseResult.GetValue(HelpOption);
 
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override PipelineResult Execute(PipelineResult pipelineResult)
     {
         // TODO: Match testable output pattern
         pipelineResult.ConsoleHack.WriteLine("Help me!");
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
+        return pipelineResult;
     }
 
     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,20 @@ 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);
+        return TearDownSubsystems(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 +95,18 @@ 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 PipelineResult 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);
+                pipelineResult = subsystem.TearDown(pipelineResult);
             }
         }
-        return cliExit;
+        return pipelineResult;
     }
 
     protected virtual void ExecuteSubsystems(PipelineResult pipelineResult)
diff --git a/src/System.CommandLine.Subsystems/Subsystems/CliSubsystem.cs b/src/System.CommandLine.Subsystems/Subsystems/CliSubsystem.cs
@@ -66,9 +66,12 @@ 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 PipelineResult Execute(PipelineResult pipelineResult)
+    {
+        pipelineResult.NotRun(pipelineResult.ParseResult);
+        return pipelineResult;
+    }
 
     internal PipelineResult ExecuteIfNeeded(PipelineResult pipelineResult)
         => ExecuteIfNeeded(pipelineResult.ParseResult, pipelineResult);
@@ -111,7 +114,7 @@ protected internal virtual CliConfiguration Initialize(InitializationContext con
         => context.Configuration;
 
     // TODO: Determine if this is needed.
-    protected internal virtual CliExit TearDown(CliExit cliExit)
-        => cliExit;
+    protected internal virtual PipelineResult TearDown(PipelineResult 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
@@ -8,16 +8,16 @@ public class Subsystem
     public static void Initialize(CliSubsystem subsystem, CliConfiguration configuration, IReadOnlyList<string> args)
         => subsystem.Initialize(new InitializationContext(configuration, args));
 
-    public static CliExit Execute(CliSubsystem subsystem, PipelineResult pipelineResult)
+    public static PipelineResult Execute(CliSubsystem subsystem, PipelineResult pipelineResult)
         => subsystem.Execute(pipelineResult);
 
     public static bool GetIsActivated(CliSubsystem subsystem, ParseResult parseResult)
         => subsystem.GetIsActivated(parseResult);
 
-    public static CliExit ExecuteIfNeeded(CliSubsystem subsystem, ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)
-        => new(subsystem.ExecuteIfNeeded(new PipelineResult(parseResult, rawInput, null, consoleHack)));
+    public static PipelineResult ExecuteIfNeeded(CliSubsystem subsystem, ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)
+        => subsystem.ExecuteIfNeeded(new PipelineResult(parseResult, rawInput, null, consoleHack));
 
-    public static CliExit Execute(CliSubsystem subsystem, ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)
+    public static PipelineResult Execute(CliSubsystem subsystem, ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)
         => subsystem.Execute(new PipelineResult(parseResult, rawInput, null, consoleHack));
 
 
diff --git a/src/System.CommandLine.Subsystems/ValueSubsystem.cs b/src/System.CommandLine.Subsystems/ValueSubsystem.cs
@@ -29,7 +29,7 @@ protected internal override bool GetIsActivated(ParseResult? parseResult)
     /// <remarks>
     /// Note to inheritors: Call base for all ValueSubsystem methods that you override to ensure correct behavior
     /// </remarks>
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override PipelineResult Execute(PipelineResult pipelineResult)
     {
         parseResult ??= pipelineResult.ParseResult;
         return base.Execute(pipelineResult);
diff --git a/src/System.CommandLine.Subsystems/VersionSubsystem.cs b/src/System.CommandLine.Subsystems/VersionSubsystem.cs
@@ -49,15 +49,15 @@ protected internal override CliConfiguration Initialize(InitializationContext co
     protected internal override bool GetIsActivated(ParseResult? parseResult)
         => parseResult is not null && parseResult.GetValue<bool>("--version");
 
-    protected internal override CliExit Execute(PipelineResult pipelineResult)
+    protected internal override PipelineResult Execute(PipelineResult pipelineResult)
     {
         var subsystemVersion = SpecificVersion;
         var version = subsystemVersion is null
             ? CliExecutable.ExecutableVersion
             : subsystemVersion;
         pipelineResult.ConsoleHack.WriteLine(version);
-        pipelineResult.AlreadyHandled = true;
-        return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);
+        pipelineResult.SetSuccess();
+        return pipelineResult;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,11 @@ internal class AlternateSubsystems`
`10`	`10`	`{`
`11`	`11`	`internal class AlternateVersion : VersionSubsystem`
`12`	`12`	`{`
`13`		`- protected override CliExit Execute(PipelineResult pipelineResult)`
	`13`	`+ protected override PipelineResult 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();`
	`17`	`+ return pipelineResult;`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`@@ -29,12 +29,13 @@ public VersionThatUsesHelpData(CliSymbol symbol)`
`29`	`29`
`30`	`30`	`private CliSymbol Symbol { get; }`
`31`	`31`
`32`		`- protected override CliExit Execute(PipelineResult pipelineResult)`
	`32`	`+ protected override PipelineResult Execute(PipelineResult pipelineResult)`
`33`	`33`	`{`
`34`	`34`	`TryGetAnnotation(Symbol, HelpAnnotations.Description, out string? description);`
`35`	`35`	`pipelineResult.ConsoleHack.WriteLine(description);`
`36`	`36`	`pipelineResult.AlreadyHandled = true;`
`37`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`37`	`+ pipelineResult.SetSuccess();`
	`38`	`+ return pipelineResult;`
`38`	`39`	`}`
`39`	`40`	`}`
`40`	`41`
`@@ -51,16 +52,16 @@ protected override CliConfiguration Initialize(InitializationContext context)`
`51`	`52`	`return base.Initialize(context);`
`52`	`53`	`}`
`53`	`54`
`54`		`- protected override CliExit Execute(PipelineResult pipelineResult)`
	`55`	`+ protected override PipelineResult Execute(PipelineResult pipelineResult)`
`55`	`56`	`{`
`56`	`57`	`ExecutionWasRun = true;`
`57`	`58`	`return base.Execute(pipelineResult);`
`58`	`59`	`}`
`59`	`60`
`60`		`- protected override CliExit TearDown(CliExit cliExit)`
	`61`	`+ protected override PipelineResult TearDown(PipelineResult pipelineResult)`
`61`	`62`	`{`
`62`	`63`	`TeardownWasRun = true;`
`63`		`- return base.TearDown(cliExit);`
	`64`	`+ return base.TearDown(pipelineResult);`
`64`	`65`	`}`
`65`	`66`	`}`
`66`	`67`
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,10 @@ 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 PipelineResult Execute(PipelineResult pipelineResult)`
`22`	`22`	`{`
`23`	`23`	`pipelineResult.ConsoleHack.WriteLine("Not yet implemented");`
`24`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`24`	`+ pipelineResult.SetSuccess();`
	`25`	`+ return pipelineResult;`
`25`	`26`	`}`
`26`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,15 @@ 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 PipelineResult 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`	`+ return pipelineResult;`
`24`	`25`	`}`
`25`	`26`
`26`	`27`
Original file line number	Diff line number	Diff line change
`@@ -23,14 +23,15 @@ 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 PipelineResult 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`	`+ return pipelineResult;`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`public void Report(ConsoleHack consoleHack, IReadOnlyList<ParseError> errors)`
Original file line number	Diff line number	Diff line change
`@@ -34,11 +34,12 @@ protected internal override CliConfiguration Initialize(InitializationContext co`
`34`	`34`	`protected internal override bool GetIsActivated(ParseResult? parseResult)`
`35`	`35`	`=> parseResult is not null && parseResult.GetValue(HelpOption);`
`36`	`36`
`37`		`- protected internal override CliExit Execute(PipelineResult pipelineResult)`
	`37`	`+ protected internal override PipelineResult Execute(PipelineResult pipelineResult)`
`38`	`38`	`{`
`39`	`39`	`// TODO: Match testable output pattern`
`40`	`40`	`pipelineResult.ConsoleHack.WriteLine("Help me!");`
`41`		`- return CliExit.SuccessfullyHandled(pipelineResult.ParseResult);`
	`41`	`+ pipelineResult.SetSuccess();`
	`42`	`+ return pipelineResult;`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`public bool TryGetDescription (CliSymbol symbol, out string? description)`
Original file line number	Diff line number	Diff line change
`@@ -51,20 +51,20 @@ public ParseResult Parse(CliConfiguration configuration, IReadOnlyList<string> a`
`51`	`51`	`return parseResult;`
`52`	`52`	`}`
`53`	`53`
`54`		`- public CliExit Execute(CliConfiguration configuration, string rawInput, ConsoleHack? consoleHack = null)`
	`54`	`+ public PipelineResult Execute(CliConfiguration configuration, string rawInput, ConsoleHack? consoleHack = null)`
`55`	`55`	`=> Execute(configuration, CliParser.SplitCommandLine(rawInput).ToArray(), rawInput, consoleHack);`
`56`	`56`
`57`		`- public CliExit Execute(CliConfiguration configuration, string[] args, string rawInput, ConsoleHack? consoleHack = null)`
	`57`	`+ public PipelineResult Execute(CliConfiguration configuration, string[] args, string rawInput, ConsoleHack? consoleHack = null)`
`58`	`58`	`{`
`59`		`- var cliExit = Execute(Parse(configuration, args), rawInput, consoleHack);`
`60`		`- return TearDownSubsystems(cliExit);`
	`59`	`+ var pipelineResult = Execute(Parse(configuration, args), rawInput, consoleHack);`
	`60`	`+ return TearDownSubsystems(pipelineResult);`
`61`	`61`	`}`
`62`	`62`
`63`		`- public CliExit Execute(ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)`
	`63`	`+ public PipelineResult Execute(ParseResult parseResult, string rawInput, ConsoleHack? consoleHack = null)`
`64`	`64`	`{`
`65`	`65`	`var pipelineResult = new PipelineResult(parseResult, rawInput, this, consoleHack ?? new ConsoleHack());`
`66`	`66`	`ExecuteSubsystems(pipelineResult);`
`67`		`- return new CliExit(pipelineResult);`
	`67`	`+ return pipelineResult;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`// TODO: Consider whether this should be public. It would simplify testing, but would it do anything else`
`@@ -95,18 +95,18 @@ protected virtual void InitializeSubsystems(InitializationContext context)`
`95`	`95`	`/// Perform any cleanup operations`
`96`	`96`	`/// </summary>`
`97`	`97`	`/// <param name="pipelineResult">The context of the current execution</param>`
`98`		`- protected virtual CliExit TearDownSubsystems(CliExit cliExit)`
	`98`	`+ protected virtual PipelineResult TearDownSubsystems(PipelineResult pipelineResult)`
`99`	`99`	`{`
`100`		`- // TODO: Work on this design as the last cliExit wins and they may not all be well behaved`
	`100`	`+ // TODO: Work on this design as the last pipelineResult wins and they may not all be well behaved`
`101`	`101`	`var subsystems = Subsystems.Reverse();`
`102`	`102`	`foreach (var subsystem in subsystems)`
`103`	`103`	`{`
`104`	`104`	`if (subsystem is not null)`
`105`	`105`	`{`
`106`		`- cliExit = subsystem.TearDown(cliExit);`
	`106`	`+ pipelineResult = subsystem.TearDown(pipelineResult);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`		`- return cliExit;`
	`109`	`+ return pipelineResult;`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`protected virtual void ExecuteSubsystems(PipelineResult pipelineResult)`