Create Release 1.2.0 (#36)

* [FEATURE]: Binder base (#31)

* Implement abstract binders
* Refactor existing binders to use abstract base

---------

Co-authored-by: Brenton Farmer <brent.farmer@wagglebee.net>

* [FEATURE]: Implement dedicated builder and binder for CallIfBlock and PipeIfBlock (#33)
* Factor CallIfBlock* and PipeIfBlock* into their own builders and binders.

---------

Co-authored-by: Brenton Farmer <brent.farmer@wagglebee.net>

* [FEATURE]: Improve builder pattern (#35)
* Refactor builders to eliminate reliance on partial interfaces and classes

---------

Co-authored-by: Brenton Farmer <brent.farmer@wagglebee.net>

* Fix footer
* Previous version was 'v1.1.6'. Version now 'v1.2.0'.

---------

Co-authored-by: Brenton Farmer <brent.farmer@wagglebee.net>

Author: bfarmer67

Directory.Build.props

@@ -2,8 +2,8 @@
   <!-- Solution version numbers -->
   <PropertyGroup>
     <MajorVersion>1</MajorVersion>
-    <MinorVersion>1</MinorVersion>
-    <PatchVersion>6</PatchVersion>
+    <MinorVersion>2</MinorVersion>
+    <PatchVersion>0</PatchVersion>
   </PropertyGroup>
   <!-- Disable automatic package publishing -->
   <PropertyGroup>

Hyperbee.Pipeline.sln

@@ -7,8 +7,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		Directory.Build.props = Directory.Build.props
 		Directory.Build.targets = Directory.Build.targets
-		LICENSE = LICENSE
-		README.md = README.md
 		solution-helper.psm1 = solution-helper.psm1
 	EndProjectSection
 EndProject

docs/_includes/nav_footer_custom.html

@@ -1,3 +1,3 @@
 <footer class="site-footer">
-    Hyperbee Json Docs
+    Hyperbee Pipeline Docs
 </footer>

docs/syntax.md

@@ -101,7 +101,7 @@ var count = 0;
 var command = PipelineFactory
     .Start<string>()
     .Pipe( ( ctx, arg ) => arg.Split( ' ' ) )
-    .ForEach<string>( builder => builder
+    .ForEach().Type<string>( builder => builder
         .Pipe( ( ctx, arg ) => count += 10 )
     )
     .Pipe( ( ctx, arg ) => count += 5 )
@@ -117,6 +117,21 @@ Assert.AreEqual( count, 25 );
 `Reduce` and `ReduceAync` allow you to transform an enumerable pipeline input to a single value. You can specify a reducer function
 that defines how the elements should be combined, and a builder function that creates the pipeline for processing the elements.### Cancel
 
+```csharp
+var command = PipelineFactory
+     .Start<string>()
+     .Pipe( ( ctx, arg ) => arg.Split( ' ' ) )
+     .Reduce().Type<string, int>( ( aggregate, value ) => aggregate + value, builder => builder
+         .Pipe( ( ctx, arg ) => int.Parse( arg ) + 10 )
+     )
+     .Pipe( ( ctx, arg ) => arg + 5 )
+     .Build();
+
+var result = await command( new PipelineContext(), "1 2 3 4 5" );
+
+Assert.AreEqual( result, 70 );
+```
+
 ### WaitAll
 
 `WaitAll` allows you to wait for concurrent pipelines to complete before continuing. You can specify a set of builders that create

src/Hyperbee.Pipeline/Binders/Abstractions/Binder.cs

@@ -0,0 +1,26 @@
+using Hyperbee.Pipeline.Context;
+using Hyperbee.Pipeline.Extensions.Implementation;
+
+namespace Hyperbee.Pipeline.Binders.Abstractions;
+
+internal abstract class Binder<TInput, TOutput>
+{
+    protected FunctionAsync<TInput, TOutput> Pipeline { get; }
+    protected Action<IPipelineContext> Configure { get; }
+
+    protected Binder( FunctionAsync<TInput, TOutput> function, Action<IPipelineContext> configure )
+    {
+        Pipeline = function;
+        Configure = configure;
+    }
+
+    protected virtual async Task<(TOutput Result, bool Canceled)> ProcessPipelineAsync( IPipelineContext context, TInput argument )
+    {
+        var result = await Pipeline( context, argument ).ConfigureAwait( false );
+
+        var contextControl = (IPipelineContextControl) context;
+        var canceled = contextControl.HandleCancellationRequested( result );
+
+        return (canceled ? default : result, canceled);
+    }
+}

src/Hyperbee.Pipeline/Binders/Abstractions/BlockBinder.cs

@@ -0,0 +1,20 @@
+using Hyperbee.Pipeline.Context;
+
+namespace Hyperbee.Pipeline.Binders.Abstractions;
+
+internal abstract class BlockBinder<TInput, TOutput> : Binder<TInput, TOutput>
+{
+    protected BlockBinder( FunctionAsync<TInput, TOutput> function, Action<IPipelineContext> configure )
+        : base( function, configure )
+    {
+    }
+
+    // Using TArgument instead of TOutput allows more capabilities for special
+    // use cases where the next argument is not the same as the output type
+    // like ReduceBlockBinder and ForEachBlockBinder
+
+    protected virtual async Task<TNext> ProcessBlockAsync<TArgument, TNext>( FunctionAsync<TArgument, TNext> blockFunction, IPipelineContext context, TArgument nextArgument )
+    {
+        return await blockFunction( context, nextArgument ).ConfigureAwait( false );
+    }
+}

src/Hyperbee.Pipeline/Binders/Abstractions/ConditionalBlockBinder.cs

@@ -0,0 +1,31 @@
+using System.Runtime.CompilerServices;
+using Hyperbee.Pipeline.Context;
+
+namespace Hyperbee.Pipeline.Binders.Abstractions;
+
+internal abstract class ConditionalBlockBinder<TInput, TOutput> : BlockBinder<TInput, TOutput>
+{
+    protected Function<TOutput, bool> Condition { get; }
+
+    protected ConditionalBlockBinder( Function<TOutput, bool> condition, FunctionAsync<TInput, TOutput> function, Action<IPipelineContext> configure )
+        : base( function, configure )
+    {
+        Condition = condition;
+    }
+
+    protected override async Task<TNext> ProcessBlockAsync<TArgument, TNext>( FunctionAsync<TArgument, TNext> blockFunction, IPipelineContext context, TArgument nextArgument )
+    {
+        if ( Condition != null && !Condition( context, CastTypeArg<TArgument, TOutput>( nextArgument ) ) )
+        {
+            return CastTypeArg<TArgument, TNext>( nextArgument );
+        }
+
+        return await base.ProcessBlockAsync( blockFunction, context, nextArgument ).ConfigureAwait( false );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    private static TResult CastTypeArg<TType, TResult>( TType input )
+    {
+        return (TResult) (object) input;
+    }
+}

src/Hyperbee.Pipeline/Binders/Abstractions/StatementBinder.cs

@@ -0,0 +1,31 @@
+using Hyperbee.Pipeline.Context;
+using Hyperbee.Pipeline.Extensions.Implementation;
+
+namespace Hyperbee.Pipeline.Binders.Abstractions;
+
+internal abstract class StatementBinder<TInput, TOutput> : Binder<TInput, TOutput>
+{
+    protected MiddlewareAsync<object, object> Middleware { get; }
+
+    protected StatementBinder( FunctionAsync<TInput, TOutput> function, MiddlewareAsync<object, object> middleware, Action<IPipelineContext> configure )
+        : base( function, configure )
+    {
+        Middleware = middleware;
+    }
+
+    protected virtual async Task<TNext> ProcessStatementAsync<TNext>( FunctionAsync<TOutput, TNext> nextFunction, IPipelineContext context, TOutput nextArgument, string frameName )
+    {
+        var contextControl = (IPipelineContextControl) context;
+
+        using var _ = contextControl.CreateFrame( context, Configure, frameName );
+
+        if ( Middleware == null )
+            return await nextFunction( context, nextArgument ).ConfigureAwait( false );
+
+        return (TNext) await Middleware(
+            context,
+            nextArgument,
+            async ( context1, argument1 ) => await nextFunction( context1, (TOutput) argument1 ).ConfigureAwait( false )
+        ).ConfigureAwait( false );
+    }
+}

src/Hyperbee.Pipeline/Binders/CallBlockBinder.cs

@@ -1,30 +1,24 @@
-namespace Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Binders.Abstractions;
 
-internal class CallBlockBinder<TInput, TOutput>
-{
-    private FunctionAsync<TInput, TOutput> Pipeline { get; }
-    private Function<TOutput, bool> Condition { get; }
+namespace Hyperbee.Pipeline.Binders;
 
+internal class CallBlockBinder<TInput, TOutput> : BlockBinder<TInput, TOutput>
+{
     public CallBlockBinder( FunctionAsync<TInput, TOutput> function )
-        : this( null, function )
-    {
-    }
-
-    public CallBlockBinder( Function<TOutput, bool> condition, FunctionAsync<TInput, TOutput> function )
+        : base( function, default )
     {
-        Condition = condition;
-        Pipeline = function;
     }
 
     public FunctionAsync<TInput, TOutput> Bind( FunctionAsync<TOutput, object> next )
     {
         return async ( context, argument ) =>
         {
-            var nextArgument = await Pipeline( context, argument ).ConfigureAwait( false );
+            var (nextArgument, canceled) = await ProcessPipelineAsync( context, argument ).ConfigureAwait( false );
 
-            if ( Condition == null || Condition( context, nextArgument ) )
-                await next( context, nextArgument ).ConfigureAwait( false );
+            if ( canceled )
+                return default;
 
+            await ProcessBlockAsync( next, context, nextArgument ).ConfigureAwait( false );
             return nextArgument;
         };
     }

src/Hyperbee.Pipeline/Binders/CallIfBlockBinder.cs

@@ -0,0 +1,25 @@
+using Hyperbee.Pipeline.Binders.Abstractions;
+
+namespace Hyperbee.Pipeline.Binders;
+
+internal class CallIfBlockBinder<TInput, TOutput> : ConditionalBlockBinder<TInput, TOutput>
+{
+    public CallIfBlockBinder( Function<TOutput, bool> condition, FunctionAsync<TInput, TOutput> function )
+        : base( condition, function, default )
+    {
+    }
+
+    public FunctionAsync<TInput, TOutput> Bind( FunctionAsync<TOutput, object> next )
+    {
+        return async ( context, argument ) =>
+        {
+            var (nextArgument, canceled) = await ProcessPipelineAsync( context, argument ).ConfigureAwait( false );
+
+            if ( canceled )
+                return default;
+
+            await ProcessBlockAsync( next, context, nextArgument ).ConfigureAwait( false );
+            return nextArgument;
+        };
+    }
+}