finished refactoring config cretor

src/Ocelot/Configuration/Builder/RateLimitOptionsBuilder.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+
+namespace Ocelot.Configuration.Builder
+{
+    public class RateLimitOptionsBuilder
+    {
+        private bool _enableRateLimiting;
+        private string _clientIdHeader;
+        private List<string> _clientWhitelist;
+        private bool _disableRateLimitHeaders;
+        private string _quotaExceededMessage;
+        private string _rateLimitCounterPrefix;
+        private RateLimitRule _rateLimitRule;
+        private int _httpStatusCode;
+
+        public RateLimitOptionsBuilder WithEnableRateLimiting(bool enableRateLimiting)
+        {
+            _enableRateLimiting = enableRateLimiting;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithClientIdHeader(string clientIdheader)
+        {
+            _clientIdHeader = clientIdheader;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithClientWhiteList(List<string> clientWhitelist)
+        {
+            _clientWhitelist = clientWhitelist;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithDisableRateLimitHeaders(bool disableRateLimitHeaders)
+        {
+            _disableRateLimitHeaders = disableRateLimitHeaders;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithQuotaExceededMessage(string quotaExceededMessage)
+        {
+            _quotaExceededMessage = quotaExceededMessage;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithRateLimitCounterPrefix(string rateLimitCounterPrefix)
+        {
+            _rateLimitCounterPrefix = rateLimitCounterPrefix;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithRateLimitRule(RateLimitRule rateLimitRule)
+        {
+            _rateLimitRule = rateLimitRule;
+            return this;
+        }
+
+        public RateLimitOptionsBuilder WithHttpStatusCode(int httpStatusCode)
+        {
+            _httpStatusCode = httpStatusCode;
+            return this;
+        }
+
+        public RateLimitOptions Build()
+        {
+            return new RateLimitOptions(_enableRateLimiting, _clientIdHeader, _clientWhitelist, 
+                _disableRateLimitHeaders, _quotaExceededMessage, _rateLimitCounterPrefix, 
+                _rateLimitRule, _httpStatusCode);
+        }
+    }
+}

src/Ocelot/Configuration/Creator/FileOcelotConfigurationCreator.cs

@@ -34,6 +34,7 @@ namespace Ocelot.Configuration.Creator
         private IServiceProviderConfigurationCreator _serviceProviderConfigCreator;
         private IQoSOptionsCreator _qosOptionsCreator;
         private IReRouteOptionsCreator _fileReRouteOptionsCreator;
+        private IRateLimitOptionsCreator _rateLimitOptionsCreator;
 
         public FileOcelotConfigurationCreator(
             IOptions<FileConfiguration> options, 
@@ -49,9 +50,11 @@ namespace Ocelot.Configuration.Creator
             IRequestIdKeyCreator requestIdKeyCreator,
             IServiceProviderConfigurationCreator serviceProviderConfigCreator,
             IQoSOptionsCreator qosOptionsCreator,
-            IReRouteOptionsCreator fileReRouteOptionsCreator
+            IReRouteOptionsCreator fileReRouteOptionsCreator,
+            IRateLimitOptionsCreator rateLimitOptionsCreator
             )
         {
+            _rateLimitOptionsCreator = rateLimitOptionsCreator;
             _requestIdKeyCreator = requestIdKeyCreator;
             _upstreamTemplatePatternCreator = upstreamTemplatePatternCreator;
             _authOptionsCreator = authOptionsCreator;
@@ -131,7 +134,7 @@ namespace Ocelot.Configuration.Creator
 
             var qosOptions = _qosOptionsCreator.Create(fileReRoute);
 
-            var rateLimitOption = BuildRateLimitOptions(fileReRoute, globalConfiguration, fileReRouteOptions.EnableRateLimiting);
+            var rateLimitOption = _rateLimitOptionsCreator.Create(fileReRoute, globalConfiguration, fileReRouteOptions.EnableRateLimiting);
 
             var reRoute = new ReRouteBuilder()
                 .WithDownstreamPathTemplate(fileReRoute.DownstreamPathTemplate)
@@ -165,21 +168,6 @@ namespace Ocelot.Configuration.Creator
             return reRoute;
         }
 
-        private static RateLimitOptions BuildRateLimitOptions(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration, bool enableRateLimiting)
-        {
-            RateLimitOptions rateLimitOption = null;
-            if (enableRateLimiting)
-            {
-                rateLimitOption = new RateLimitOptions(enableRateLimiting, globalConfiguration.RateLimitOptions.ClientIdHeader,
-                   fileReRoute.RateLimitOptions.ClientWhitelist, globalConfiguration.RateLimitOptions.DisableRateLimitHeaders,
-                   globalConfiguration.RateLimitOptions.QuotaExceededMessage, globalConfiguration.RateLimitOptions.RateLimitCounterPrefix,
-                   new RateLimitRule(fileReRoute.RateLimitOptions.Period, TimeSpan.FromSeconds(fileReRoute.RateLimitOptions.PeriodTimespan), fileReRoute.RateLimitOptions.Limit)
-                   , globalConfiguration.RateLimitOptions.HttpStatusCode);
-            }
-
-            return rateLimitOption;
-        }
-
         private string CreateReRouteKey(FileReRoute fileReRoute)
         {
             //note - not sure if this is the correct key, but this is probably the only unique key i can think of given my poor brain

src/Ocelot/Configuration/Creator/IRateLimitOptionsCreator.cs

@@ -0,0 +1,9 @@
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public interface IRateLimitOptionsCreator
+    {
+        RateLimitOptions Create(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration, bool enableRateLimiting);
+    }
+}

src/Ocelot/Configuration/Creator/RateLimitOptionsCreator.cs

@@ -0,0 +1,32 @@
+using System;
+using Ocelot.Configuration.Builder;
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public class RateLimitOptionsCreator : IRateLimitOptionsCreator
+    {
+        public RateLimitOptions Create(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration, bool enableRateLimiting)
+        {
+            RateLimitOptions rateLimitOption = null;
+
+            if (enableRateLimiting)
+            {
+                rateLimitOption = new RateLimitOptionsBuilder()
+                    .WithClientIdHeader(globalConfiguration.RateLimitOptions.ClientIdHeader)
+                    .WithClientWhiteList(fileReRoute.RateLimitOptions.ClientWhitelist)
+                    .WithDisableRateLimitHeaders(globalConfiguration.RateLimitOptions.DisableRateLimitHeaders)
+                    .WithEnableRateLimiting(fileReRoute.RateLimitOptions.EnableRateLimiting)
+                    .WithHttpStatusCode(globalConfiguration.RateLimitOptions.HttpStatusCode)
+                    .WithQuotaExceededMessage(globalConfiguration.RateLimitOptions.QuotaExceededMessage)
+                    .WithRateLimitCounterPrefix(globalConfiguration.RateLimitOptions.RateLimitCounterPrefix)
+                    .WithRateLimitRule(new RateLimitRule(fileReRoute.RateLimitOptions.Period,
+                        TimeSpan.FromSeconds(fileReRoute.RateLimitOptions.PeriodTimespan),
+                        fileReRoute.RateLimitOptions.Limit))
+                    .Build();
+            }
+
+            return rateLimitOption;
+        }
+    }
+}

src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs

@@ -67,6 +67,7 @@ namespace Ocelot.DependencyInjection
             services.AddSingleton<IServiceProviderConfigurationCreator,ServiceProviderConfigurationCreator>();
             services.AddSingleton<IQoSOptionsCreator, QoSOptionsCreator>();
             services.AddSingleton<IReRouteOptionsCreator, ReRouteOptionsCreator>();
+            services.AddSingleton<IRateLimitOptionsCreator, RateLimitOptionsCreator>();
 
             var identityServerConfiguration = IdentityServerConfigurationCreator.GetIdentityServerConfiguration();