Merge branch 'master' into bp/updatesharedinfra

Author: JimBobSquarePants

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -160,7 +160,7 @@ public ImageSharpMiddleware(
                 ? CultureInfo.InvariantCulture
                 : CultureInfo.CurrentCulture;
 
-            var commands = new HashSet<string>();
+            var commands = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             foreach (IImageWebProcessor processor in this.processors)
             {
                 foreach (string command in processor.Commands)
@@ -184,23 +184,31 @@ public ImageSharpMiddleware(
         public async Task Invoke(HttpContext context)
 #pragma warning restore IDE1006 // Naming Styles
         {
-            IDictionary<string, string> commands = this.requestParser.ParseRequestCommands(context);
+            // We expect to get concrete collection type which removes virtual dispatch concerns and enumerator allocations
+            IDictionary<string, string> parsedCommands = this.requestParser.ParseRequestCommands(context);
+            Dictionary<string, string> commands = parsedCommands as Dictionary<string, string> ?? new Dictionary<string, string>(parsedCommands, StringComparer.OrdinalIgnoreCase);
+
             if (commands.Count > 0)
             {
-                // Strip out any unknown commands.
-                foreach (string command in new List<string>(commands.Keys))
+                // Strip out any unknown commands, if needed.
+                int index = 0;
+                foreach (string command in commands.Keys)
                 {
                     if (!this.knownCommands.Contains(command))
                     {
-                        commands.Remove(command);
+                        // Need to actually remove, allocates new list to allow modifications
+                        this.StripUnknownCommands(commands, startAtIndex: index);
+                        break;
                     }
+
+                    index++;
                 }
             }
 
             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)
             {
@@ -238,6 +246,19 @@ await this.ProcessRequestAsync(
                 commands);
         }
 
+        private void StripUnknownCommands(Dictionary<string, string> commands, int startAtIndex)
+        {
+            var keys = new List<string>(commands.Keys);
+            for (int index = startAtIndex; index < keys.Count; index++)
+            {
+                string command = keys[index];
+                if (!this.knownCommands.Contains(command))
+                {
+                    commands.Remove(command);
+                }
+            }
+        }
+
         private async Task ProcessRequestAsync(
             HttpContext context,
             IImageResolver sourceImageResolver,

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/Processing/PhysicalFileSystemCacheServerTests.cs

@@ -16,8 +16,8 @@ namespace SixLabors.ImageSharp.Web.Tests.Processing
     public class PhysicalFileSystemCacheServerTests : ServerTestBase<PhysicalFileSystemCacheTestServerFixture>
     {
         private const int Width = 20;
-        private static readonly string Command = "?width=" + Width + "&v=" + Guid.NewGuid().ToString();
-        private static readonly string Command2 = "?width=" + (Width + 1) + "&v=" + Guid.NewGuid().ToString();
+        private static readonly string Command = "?invalidcommand=qwerty&width=" + Width + "&v=" + Guid.NewGuid().ToString();
+        private static readonly string Command2 = "?invalidcommand=qwerty&width=" + (Width + 1) + "&v=" + Guid.NewGuid().ToString();
 
         public PhysicalFileSystemCacheServerTests(PhysicalFileSystemCacheTestServerFixture fixture)
             : base(fixture)

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);
+        }
+    }
+}