Rename foldService to foldRoutes and others

core/src/main/scala/org/http4s/rho/CompileRoutes.scala

@@ -36,15 +36,13 @@ object CompileRoutes {
     implicit def compiler[F[_]]: CompileRoutes[F, RhoRoute.Tpe[F]] = identityCompiler[F]
   }
 
-
-  /** Convert the `Seq` of [[RhoRoute]]'s into a `HttpService`
+  /** Convert the `Seq` of [[RhoRoute]]'s into a `HttpRoutes`
     *
     * @param routes `Seq` of routes to bundle into a service.
-    * @param filter [[RhoMiddleware]] to apply to the routes.
-    * @return An `HttpService`
+    * @return An `HttpRoutes`
     */
-  def foldRoutes[F[_]: Monad](routes: Seq[RhoRoute.Tpe[F]], filter: RhoMiddleware[F]): HttpRoutes[F] = {
-    val tree = filter(routes).foldLeft(PathTree[F]()){ (t, r) => t.appendRoute(r) }
+  def foldRoutes[F[_]: Monad](routes: Seq[RhoRoute.Tpe[F]]): HttpRoutes[F] = {
+    val tree = routes.foldLeft(PathTree[F]()){ (t, r) => t.appendRoute(r) }
     Kleisli((req: Request[F]) => tree.getResult(req).toResponse)
   }
 }

core/src/main/scala/org/http4s/rho/RhoService.scala

@@ -13,12 +13,11 @@ import shapeless.{HList, HNil}
   * [[CompileRoutes]] inside the constructor.
   *
   * {{{
-  *   val srvc = new RhoService {
+  *   val srvc = new RhoService[IO] {
   *     POST / "foo" / pathVar[Int] +? param[String]("param") |>> { (p1: Int, param: String) =>
   *       Ok("success")
   *     }
   *   }
-  *
   * }}}
   *
   * @param routes Routes to prepend before elements in the constructor.
@@ -47,8 +46,9 @@ class RhoService[F[_]: Monad](routes: Seq[RhoRoute[F, _ <: HList]] = Vector.empt
   /** Get a snapshot of the collection of [[RhoRoute]]'s accumulated so far */
   final def getRoutes: Seq[RhoRoute[F, _ <: HList]] = serviceBuilder.routes()
 
-  /** Convert the [[RhoRoute]]'s accumulated into a `HttpService` */
-  final def toRoutes(filter: RhoMiddleware[F] = identity): HttpRoutes[F] = serviceBuilder.toService(filter)
+  /** Convert the [[RhoRoute]]'s accumulated into a `HttpRoutes` */
+  final def toRoutes(middleware: RhoMiddleware[F] = identity): HttpRoutes[F] =
+    serviceBuilder.toRoutes(middleware)
 
   final override def toString: String = s"RhoService(${serviceBuilder.routes().toString()})"
 

core/src/main/scala/org/http4s/rho/ServiceBuilder.scala

@@ -1,21 +1,20 @@
 package org.http4s.rho
 
+import scala.collection.immutable.VectorBuilder
 import cats.Monad
-import org.http4s._
 import shapeless.HList
+import org.http4s._
 
-import scala.collection.immutable.VectorBuilder
-
-/** CompileService which accumulates routes and can build a `HttpService` */
+/** CompileService which accumulates routes and can build a `HttpRoutes` */
 final class ServiceBuilder[F[_]: Monad] private(internalRoutes: VectorBuilder[RhoRoute.Tpe[F]]) extends CompileRoutes[F, RhoRoute.Tpe[F]] {
 
-  /** Turn the accumulated routes into an `HttpService`
+  /** Turn the accumulated routes into an `HttpRoutes`
     *
-    * @param filter [[RhoMiddleware]] to apply to the collection of routes.
-    * @return An `HttpService` which can be mounted by http4s servers.
+    * @param middleware [[RhoMiddleware]] to apply to the collection of routes.
+    * @return An `HttpRoutes` which can be mounted by http4s servers.
     */
-  def toService(filter: RhoMiddleware[F] = identity): HttpRoutes[F] =
-    CompileRoutes.foldRoutes(internalRoutes.result(), filter)
+  def toRoutes(middleware: RhoMiddleware[F] = identity): HttpRoutes[F] =
+    CompileRoutes.foldRoutes(middleware.apply(internalRoutes.result()))
 
   /** Get a snapshot of the currently acquired routes */
   def routes(): Seq[RhoRoute.Tpe[F]] = internalRoutes.result()

core/src/test/scala/org/http4s/rho/CompileRoutesSpec.scala

@@ -21,16 +21,16 @@ class CompileRoutesSpec extends Specification {
       val c = ServiceBuilder[IO]()
       getFoo(c)
 
-      "GetFoo" === RRunner(c.toService()).checkOk(Request(uri=Uri(path="/hello")))
+      "GetFoo" === RRunner(c.toRoutes()).checkOk(Request(uri=Uri(path="/hello")))
     }
 
     "Build multiple routes" in {
       val c = ServiceBuilder[IO]()
       getFoo(c)
       putFoo(c)
 
-      "GetFoo" === RRunner(c.toService()).checkOk(Request(uri=Uri(path="/hello")))
-      "PutFoo" === RRunner(c.toService()).checkOk(Request(method = Method.PUT, uri=Uri(path="/hello")))
+      "GetFoo" === RRunner(c.toRoutes()).checkOk(Request(uri=Uri(path="/hello")))
+      "PutFoo" === RRunner(c.toRoutes()).checkOk(Request(method = Method.PUT, uri=Uri(path="/hello")))
     }
 
     "Make routes from a collection of RhoRoutes" in {
@@ -39,7 +39,7 @@ class CompileRoutesSpec extends Specification {
         (GET / "hello" |>> "GetFoo") ::
         (PUT / "hello" |>> "PutFoo") :: Nil
 
-      val srvc = CompileRoutes.foldRoutes[IO](routes, identity)
+      val srvc = CompileRoutes.foldRoutes[IO](routes)
       "GetFoo" === RRunner(srvc).checkOk(Request(uri=Uri(path="/hello")))
       "PutFoo" === RRunner(srvc).checkOk(Request(method = Method.PUT, uri=Uri(path="/hello")))
     }
@@ -48,7 +48,7 @@ class CompileRoutesSpec extends Specification {
       val c1 = ServiceBuilder[IO](); getFoo(c1)
       val c2 = ServiceBuilder[IO](); putFoo(c2)
 
-      val srvc = c1.append(c2.routes()).toService()
+      val srvc = c1.append(c2.routes()).toRoutes()
       "GetFoo" === RRunner(srvc).checkOk(Request(uri=Uri(path="/hello")))
       "PutFoo" === RRunner(srvc).checkOk(Request(method = Method.PUT, uri=Uri(path="/hello")))
     }

core/src/test/scala/org/http4s/rho/RequestRunner.scala

@@ -7,24 +7,25 @@ import org.http4s.HttpRoutes
 /** Helper for collecting a the body from a `RhoService` */
 trait RequestRunner {
 
-  def service: HttpRoutes[IO]
+  def httpRoutes: HttpRoutes[IO]
 
-  def checkOk(r: Request[IO]): String = checkStatus(r)(_ == Status.Ok)
+  def checkOk(req: Request[IO]): String = checkStatus(req)(_ == Status.Ok)
 
-  def checkError(r: Request[IO]): String = checkStatus(r)(_ != Status.Ok)
+  def checkError(req: Request[IO]): String = checkStatus(req)(_ != Status.Ok)
 
-  def checkStatus(r: Request[IO])(isSuccess: Status => Boolean) = {
-    val resp = service(r).value.unsafeRunSync().getOrElse(Response.notFound)
+  def checkStatus(req: Request[IO])(isSuccess: Status => Boolean): String = {
+    val resp = httpRoutes(req).value.unsafeRunSync().getOrElse(Response.notFound)
     if (isSuccess(resp.status)) getBody(resp.body)
     else sys.error(s"Invalid response code: ${resp.status}")
   }
 
   val getBody = RequestRunner.getBody _
 }
+
 object RequestRunner {
   def getBody(b: EntityBody[IO]): String = {
     new String(b.compile.toVector.unsafeRunSync.foldLeft(Array[Byte]())(_ :+ _))
   }
 }
 
-case class RRunner(service: HttpRoutes[IO]) extends RequestRunner
+case class RRunner(httpRoutes: HttpRoutes[IO]) extends RequestRunner

core/src/test/scala/org/http4s/rho/RhoServiceSpec.scala

@@ -16,7 +16,7 @@ class RhoServiceSpec extends Specification with RequestRunner {
   def Get(s: String, h: Header*): Request[IO] = construct(Method.GET, s, h:_*)
   def Put(s: String, h: Header*): Request[IO] = construct(Method.PUT, s, h:_*)
 
-  val service = new RhoService[IO] {
+  val httpRoutes = new RhoService[IO] {
     GET +? param("foo", "bar") |>> { foo: String => Ok(s"just root with parameter 'foo=$foo'") }
 
     GET / "" +? param("foo", "bar") |>> { foo: String => Ok("this definition should be hidden by the previous definition") }
@@ -95,14 +95,14 @@ class RhoServiceSpec extends Specification with RequestRunner {
 
     "Return a 405 when a path is defined but the method doesn't match" in {
       val request = Request[IO](Method.POST, uri("/hello"))
-      val resp = service(request).value.unsafeRunSync().getOrElse(Response.notFound)
+      val resp = httpRoutes(request).value.unsafeRunSync().getOrElse(Response.notFound)
 
       resp.status must_== Status.MethodNotAllowed
       resp.headers.get("Allow".ci) must beSome(Header.Raw("Allow".ci, "GET"))
     }
 
     "Yield `MethodNotAllowed` when invalid method used" in {
-      service(Put("/one/two/three")).value.unsafeRunSync().getOrElse(Response.notFound).status must_== Status.MethodNotAllowed
+      httpRoutes(Put("/one/two/three")).value.unsafeRunSync().getOrElse(Response.notFound).status must_== Status.MethodNotAllowed
     }
 
     "Consider PathMatch(\"\") a NOOP" in {
@@ -148,7 +148,7 @@ class RhoServiceSpec extends Specification with RequestRunner {
     }
 
     "NotFound on empty route" in {
-      service(Get("/one/two")).value.unsafeRunSync().getOrElse(Response.notFound).status must_== Status.NotFound
+      httpRoutes(Get("/one/two")).value.unsafeRunSync().getOrElse(Response.notFound).status must_== Status.NotFound
     }
 
     "Fail a route with a missing query" in {