Builder and extensions cleanup

src/Microsoft.AspNet.Http.Core/Extensions/MapExtensions.cs

@@ -10,19 +10,6 @@ namespace Microsoft.AspNet.Builder
 {
     public static class MapExtensions
     {
-        /// <summary>
-        /// If the request path starts with the given pathMatch, execute the app configured via configuration parameter instead of
-        /// continuing to the next component in the pipeline.
-        /// </summary>
-        /// <param name="app"></param>
-        /// <param name="pathMatch">The path to match</param>
-        /// <param name="configuration">The branch to take for positive path matches</param>
-        /// <returns></returns>
-        public static IApplicationBuilder Map([NotNull] this IApplicationBuilder app, [NotNull] string pathMatch, [NotNull] Action<IApplicationBuilder> configuration)
-        {
-            return Map(app, new PathString(pathMatch), configuration);
-        }
-
         /// <summary>
         /// If the request path starts with the given pathMatch, execute the app configured via configuration parameter instead of
         /// continuing to the next component in the pipeline.

src/Microsoft.AspNet.Http.Core/Extensions/MapWhenExtensions.cs

@@ -5,12 +5,11 @@
 using System.Threading.Tasks;
 using Microsoft.AspNet.Http;
 using Microsoft.AspNet.Builder.Extensions;
+using Microsoft.Framework.Internal;
 
 namespace Microsoft.AspNet.Builder
 {
-    using Microsoft.Framework.Internal;
     using Predicate = Func<HttpContext, bool>;
-    using PredicateAsync = Func<HttpContext, Task<bool>>;
 
     /// <summary>
     /// Extension methods for the MapWhenMiddleware
@@ -39,28 +38,5 @@ public static IApplicationBuilder MapWhen([NotNull] this IApplicationBuilder app
             };
             return app.Use(next => new MapWhenMiddleware(next, options).Invoke);
         }
-
-        /// <summary>
-        /// Branches the request pipeline based on the async result of the given predicate.
-        /// </summary>
-        /// <param name="app"></param>
-        /// <param name="predicate">Invoked asynchronously with the request environment to determine if the branch should be taken</param>
-        /// <param name="configuration">Configures a branch to take</param>
-        /// <returns></returns>
-        public static IApplicationBuilder MapWhenAsync([NotNull] this IApplicationBuilder app, [NotNull] PredicateAsync predicate, [NotNull] Action<IApplicationBuilder> configuration)
-        {
-            // create branch
-            var branchBuilder = app.New();
-            configuration(branchBuilder);
-            var branch = branchBuilder.Build();
-
-            // put middleware in pipeline
-            var options = new MapWhenOptions
-            {
-                PredicateAsync = predicate,
-                Branch = branch,
-            };
-            return app.Use(next => new MapWhenMiddleware(next, options).Invoke);
-        }
     }
 }

src/Microsoft.AspNet.Http.Core/Extensions/MapWhenMiddleware.cs

@@ -20,27 +20,13 @@ public MapWhenMiddleware([NotNull] RequestDelegate next, [NotNull] MapWhenOption
 
         public async Task Invoke([NotNull] HttpContext context)
         {
-            if (_options.Predicate != null)
+            if (_options.Predicate(context))
             {
-                if (_options.Predicate(context))
-                {
-                    await _options.Branch(context);
-                }
-                else
-                {
-                    await _next(context);
-                }
+                await _options.Branch(context);
             }
             else
             {
-                if (await _options.PredicateAsync(context))
-                {
-                    await _options.Branch(context);
-                }
-                else
-                {
-                    await _next(context);
-                }
+                await _next(context);
             }
         }
     }

src/Microsoft.AspNet.Http.Core/Extensions/MapWhenOptions.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.AspNet.Http;
+using Microsoft.Framework.Internal;
 
 namespace Microsoft.AspNet.Builder.Extensions
 {
@@ -15,12 +16,12 @@ public class MapWhenOptions
         /// <summary>
         /// The user callback that determines if the branch should be taken
         /// </summary>
-        public Func<HttpContext, bool> Predicate { get; set; }
-
-        /// <summary>
-        /// The async user callback that determines if the branch should be taken
-        /// </summary>
-        public Func<HttpContext, Task<bool>> PredicateAsync { get; set; }
+        public Func<HttpContext, bool> Predicate
+        {
+            get;
+            [param: NotNull]
+            set;
+        }
 
         /// <summary>
         /// The branch taken for a positive match

src/Microsoft.AspNet.Http.Core/Extensions/RunExtensions.cs

@@ -14,25 +14,5 @@ public static void Run([NotNull] this IApplicationBuilder app, [NotNull] Request
         {
             app.Use(_ => handler);
         }
-
-        public static void Run<TService1>(this IApplicationBuilder app, Func<HttpContext, TService1, Task> handler)
-        {
-            app.Use<TService1>((ctx, _, s1) => handler(ctx, s1));
-        }
-
-        public static void Run<TService1, TService2>(this IApplicationBuilder app, Func<HttpContext, TService1, TService2, Task> handler)
-        {
-            app.Use<TService1, TService2>((ctx, _, s1, s2) => handler(ctx, s1, s2));
-        }
-
-        public static void Run<TService1, TService2, TService3>(this IApplicationBuilder app, Func<HttpContext, TService1, TService2, TService3, Task> handler)
-        {
-            app.Use<TService1, TService2, TService3>((ctx, _, s1, s2, s3) => handler(ctx, s1, s2, s3));
-        }
-
-        public static void Run<TService1, TService2, TService3, TService4>(this IApplicationBuilder app, Func<HttpContext, TService1, TService2, TService3, TService4, Task> handler)
-        {
-            app.Use<TService1, TService2, TService3, TService4>((ctx, _, s1, s2, s3, s4) => handler(ctx, s1, s2, s3, s4));
-        }
     }
 }

src/Microsoft.AspNet.Http.Core/IApplicationBuilder.cs

@@ -10,9 +10,9 @@ public interface IApplicationBuilder
     {
         IServiceProvider ApplicationServices { get; set; }
 
-        object Server { get; set; }
+        object Server { get; }
 
-        IDictionary<string, object> Properties { get; set; }
+        IDictionary<string, object> Properties { get; }
 
         IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);
 

src/Microsoft.AspNet.Http.Core/PathString.cs

@@ -236,5 +236,23 @@ public override int GetHashCode()
         {
             return left.Add(right);
         }
+
+        /// <summary>
+        /// Implicitly creates a new PathString from the given string.
+        /// </summary>
+        /// <param name="s"></param>
+        public static implicit operator PathString(string s)
+        {
+            return new PathString(s);
+        }
+
+        /// <summary>
+        /// Implicitly calls ToString().
+        /// </summary>
+        /// <param name="path"></param>
+        public static implicit operator string(PathString path)
+        {
+            return path.ToString();
+        }
     }
 }

src/Microsoft.AspNet.Http/ApplicationBuilder.cs

@@ -19,6 +19,12 @@ public ApplicationBuilder(IServiceProvider serviceProvider)
             ApplicationServices = serviceProvider;
         }
 
+        public ApplicationBuilder(IServiceProvider serviceProvider, object server)
+            : this(serviceProvider)
+        {
+            SetProperty(Constants.BuilderProperties.ServerInformation, server);
+        }
+
         private ApplicationBuilder(ApplicationBuilder builder)
         {
             Properties = builder.Properties;
@@ -42,13 +48,9 @@ public object Server
             {
                 return GetProperty<object>(Constants.BuilderProperties.ServerInformation);
             }
-            set
-            {
-                SetProperty<object>(Constants.BuilderProperties.ServerInformation, value);
-            }
         }
 
-        public IDictionary<string, object> Properties { get; set; }
+        public IDictionary<string, object> Properties { get; }
 
         private T GetProperty<T>(string key)
         {

test/Microsoft.AspNet.Http.Core.Tests/MapPathMiddlewareTests.cs

@@ -149,7 +149,7 @@ public void ChainedRoutes_Success()
             var builder = new ApplicationBuilder(serviceProvider: null);
             builder.Map("/route1", map =>
             {
-                map.Map((string)"/subroute1", UseSuccess);
+                map.Map("/subroute1", UseSuccess);
                 map.Run(NotImplemented);
             });
             builder.Map("/route2/subroute2", UseSuccess);

test/Microsoft.AspNet.Http.Core.Tests/MapPredicateMiddlewareTests.cs

@@ -16,7 +16,6 @@ namespace Microsoft.AspNet.Builder.Extensions
     public class MapPredicateMiddlewareTests
     {
         private static readonly Predicate NotImplementedPredicate = new Predicate(envionment => { throw new NotImplementedException(); });
-        private static readonly PredicateAsync NotImplementedPredicateAsync = new PredicateAsync(envionment => { throw new NotImplementedException(); });
 
         private static Task Success(HttpContext context)
         {
@@ -49,16 +48,6 @@ private bool FalsePredicate(HttpContext context)
             return false;
         }
 
-        private Task<bool> TruePredicateAsync(HttpContext context)
-        {
-            return Task.FromResult<bool>(true);
-        }
-
-        private Task<bool> FalsePredicateAsync(HttpContext context)
-        {
-            return Task.FromResult<bool>(false);
-        }
-
         [Fact]
         public void NullArguments_ArgumentNullException()
         {
@@ -113,31 +102,6 @@ public void PredicateFalseAction_PassThrough()
             Assert.Equal(200, context.Response.StatusCode);
         }
 
-        [Fact]
-        public void PredicateAsyncTrueAction_BranchTaken()
-        {
-            HttpContext context = CreateRequest();
-            var builder = new ApplicationBuilder(serviceProvider: null);
-            builder.MapWhenAsync(TruePredicateAsync, UseSuccess);
-            var app = builder.Build();
-            app.Invoke(context).Wait();
-
-            Assert.Equal(200, context.Response.StatusCode);
-        }
-
-        [Fact]
-        public void PredicateAsyncFalseAction_PassThrough()
-        {
-            HttpContext context = CreateRequest();
-            var builder = new ApplicationBuilder(serviceProvider: null);
-            builder.MapWhenAsync(FalsePredicateAsync, UseNotImplemented);
-            builder.Run(Success);
-            var app = builder.Build();
-            app.Invoke(context).Wait();
-
-            Assert.Equal(200, context.Response.StatusCode);
-        }
-
         [Fact]
         public void ChainedPredicates_Success()
         {
@@ -155,23 +119,6 @@ public void ChainedPredicates_Success()
             Assert.Equal(200, context.Response.StatusCode);
         }
 
-        [Fact]
-        public void ChainedPredicatesAsync_Success()
-        {
-            var builder = new ApplicationBuilder(serviceProvider: null);
-            builder.MapWhenAsync(TruePredicateAsync, map1 =>
-            {
-                map1.MapWhenAsync((PredicateAsync)FalsePredicateAsync, UseNotImplemented);
-                map1.MapWhenAsync((PredicateAsync)TruePredicateAsync, map2 => map2.MapWhenAsync((PredicateAsync)TruePredicateAsync, UseSuccess));
-                map1.Run(NotImplemented);
-            });
-            var app = builder.Build();
-
-            HttpContext context = CreateRequest();
-            app.Invoke(context).Wait();
-            Assert.Equal(200, context.Response.StatusCode);
-        }
-
         private HttpContext CreateRequest()
         {
             HttpContext context = new DefaultHttpContext();