Merge pull request #183 from ronaldbarendse/bugfix/processing-order

Order and filter processors by supported commands

Author: JimBobSquarePants

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -188,10 +188,10 @@ public async Task Invoke(HttpContext context)
             IDictionary<string, string> commands = this.requestParser.ParseRequestCommands(context);
             if (commands.Count > 0)
             {
-                // Strip out any unknown commands.
+                // Strip out any unknown commands
                 foreach (string command in new List<string>(commands.Keys))
                 {
-                    if (!this.knownCommands.Contains(command))
+                    if (!this.knownCommands.Contains(command, StringComparer.OrdinalIgnoreCase))
                     {
                         commands.Remove(command);
                     }
@@ -201,7 +201,7 @@ public async Task Invoke(HttpContext context)
             await this.options.OnParseCommandsAsync.Invoke(
                 new ImageCommandContext(context, commands, this.commandParser, this.parserCulture));
 
-            // Get the correct service for the request.
+            // Get the correct service for the request
             IImageProvider provider = null;
             foreach (IImageProvider resolver in this.providers)
             {

src/ImageSharp.Web/Processors/WebProcessingExtensions.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using Microsoft.Extensions.Logging;
@@ -33,15 +34,66 @@ public static FormattedImage Process(
             CommandParser commandParser,
             CultureInfo culture)
         {
-            if (commands.Count != 0)
+            var commandKeys = new List<string>(commands.Keys);
+
+            foreach (IImageWebProcessor processor in processors.GetBySupportedCommands(commandKeys))
+            {
+                source = processor.Process(source, logger, commands, commandParser, culture);
+            }
+
+            return source;
+        }
+
+        /// <summary>
+        /// Sorts the processors according to the first supported command and removes processors without supported commands.
+        /// </summary>
+        /// <param name="processors">The collection of available processors.</param>
+        /// <param name="commands">The parsed collection of processing commands.</param>
+        /// <returns>
+        /// The sorted proccessors that supports any of the specified commands.
+        /// </returns>
+        public static IEnumerable<IImageWebProcessor> GetBySupportedCommands(this IEnumerable<IImageWebProcessor> processors, List<string> commands)
+        {
+            var indexedProcessors = new List<(int Index, IImageWebProcessor Processor)>();
+
+            foreach (IImageWebProcessor processor in processors)
             {
-                foreach (IImageWebProcessor processor in processors)
+                // Get index of first supported command
+                int index = commands.FindIndex(c => processor.IsSupportedCommand(c));
+                if (index != -1)
                 {
-                    source = processor.Process(source, logger, commands, commandParser, culture);
+                    indexedProcessors.Add((index, processor));
                 }
             }
 
-            return source;
+            indexedProcessors.Sort((x, y) => x.Index.CompareTo(y.Index));
+
+            // Return sorted processors
+            foreach ((int _, IImageWebProcessor processor) in indexedProcessors)
+            {
+                yield return processor;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified command is supported by the processor
+        /// </summary>
+        /// <param name="processor">The processor.</param>
+        /// <param name="command">The command.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified command is supported by the processor; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsSupportedCommand(this IImageWebProcessor processor, string command)
+        {
+            foreach (string processorCommand in processor.Commands)
+            {
+                if (processorCommand.Equals(command, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+
+            return false;
         }
     }
 }

tests/ImageSharp.Web.Tests/Processors/WebProcessingExtensionsTests.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Collections.Generic;
+using System.Linq;
+using SixLabors.ImageSharp.Web.Processors;
+using SixLabors.ImageSharp.Web.Tests.DependencyInjection;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Web.Tests.Processors
+{
+    public class WebProcessingExtensionsTests
+    {
+        [Fact]
+        public void WebProcessingExtensions_GetBySupportedCommands()
+        {
+            var processors = new IImageWebProcessor[]
+            {
+                new JpegQualityWebProcessor(),
+                new ResizeWebProcessor(),
+                new BackgroundColorWebProcessor(),
+                new MockWebProcessor()
+            };
+
+            var commands = new List<string>
+            {
+                ResizeWebProcessor.Width,
+                JpegQualityWebProcessor.Quality,
+                ResizeWebProcessor.Height
+            };
+
+            var supportedProcessors = WebProcessingExtensions.GetBySupportedCommands(processors, commands).ToArray();
+
+            Assert.Equal(2, supportedProcessors.Length);
+            Assert.IsType<ResizeWebProcessor>(supportedProcessors[0]);
+            Assert.IsType<JpegQualityWebProcessor>(supportedProcessors[1]);
+        }
+
+        [Fact]
+        public void WebProcessingExtensions_GetBySupportedCommands_Empty()
+        {
+            var processors = new IImageWebProcessor[]
+            {
+                new MockWebProcessor()
+            };
+
+            var commands = new List<string>();
+
+            var supportedProcessors = WebProcessingExtensions.GetBySupportedCommands(processors, commands).ToArray();
+
+            Assert.Empty(supportedProcessors);
+        }
+    }
+}