Use tuplez.Composition instead of our Tupler. Fixes #12

Author: raquo

README.md

@@ -87,8 +87,8 @@ or an error of type `A` (if the segment could not retrieve the information).
 
 `PathSegment`s are immutable objects that can be composed together with the `/` operator. This operator is associative
 and creates, given two `PathSegment`s with type parameters `T` and `U`, will create a `PathSegment` with type parameter,
-roughly, `(T, U)` (with some additional rules described in the `Tupler` class that, without entering details, flattens
-the tuples and remove `Unit`s). So if `T =:= (String, Int)` and `U =:= (String, Double)`, you'll get the type
+roughly, `(T, U)` (with some additional rules described in the `Composition` class that, without entering details, flattens
+the tuples and removes `Unit`s). So if `T =:= (String, Int)` and `U =:= (String, Double)`, you'll get the type
 `(String, Int, String, Double)`.
 
 When a `PathSegment` matches a URL, it internally receives the list of `Segment`s, consumes one or several of them, and
@@ -278,6 +278,10 @@ import urldsl.language.dummyErrorImpl._
 
 url-dsl was thought with one possible goal in mind, the one of creating a routing system. An example of how to do that can be found [here](shared/src/test/scala/urldsl/examples/RouterUseCaseExample.scala).
 
+## Moving from 0.4.x to 0.5.x
+
+In 0.5.0 we replaced our `Tupler` with the `Composition` type from the [tuplez](https://github.com/tulz-app/tuplez) library. It works exactly the same for most use cases, but if your data types are complex enough that URL-DSL previously gave you nested tuples, those tuples will generally be flattened now.
+
 ## Moving from 0.2.0 to 0.3.x
 
 If you come from version 0.2.0, here are a few things that you should pay attention to.

build.sbt

@@ -26,6 +26,7 @@ lazy val `url-dsl` = crossProject(JSPlatform, JVMPlatform)
   .settings(name := "url-dsl")
   .settings(
     libraryDependencies ++= Seq(
+      "app.tulz" %%% "tuplez-full-light" % "0.4.0-M1",
       "org.scalatest" %%% "scalatest" % "3.2.9" % "test",
       "org.scalacheck" %%% "scalacheck" % "1.15.4" % "test"
     )

url-dsl/src/main/scala/urldsl/language/PathSegment.scala

@@ -4,6 +4,8 @@ import urldsl.errors.{DummyError, ErrorFromThrowable, PathMatchingError, SimpleP
 import urldsl.url.{UrlStringDecoder, UrlStringGenerator, UrlStringParserGenerator}
 import urldsl.vocabulary._
 
+import app.tulz.tuplez.Composition
+
 import scala.language.implicitConversions
 
 /**
@@ -84,20 +86,20 @@ trait PathSegment[T, +A] extends UrlPart[T, A] {
   final def createPart(t: T, encoder: UrlStringGenerator): String = createPath(t, encoder)
 
   /**
-    * Concatenates `this` [[urldsl.language.PathSegment]] with `that` one, "tupling" the types with the [[Tupler]]
+    * Concatenates `this` [[urldsl.language.PathSegment]] with `that` one, "tupling" the types with the [[Composition]]
     * rules.
     */
-  final def /[U, A1 >: A](that: PathSegment[U, A1])(implicit ev: Tupler[T, U]): PathSegment[ev.Out, A1] =
-    PathSegment.factory[ev.Out, A1](
+  final def /[U, A1 >: A](that: PathSegment[U, A1])(implicit c: Composition[T, U]): PathSegment[c.Composed, A1] =
+    PathSegment.factory[c.Composed, A1](
       (segments: List[Segment]) =>
         for {
           firstOut <- this.matchSegments(segments)
           PathMatchOutput(t, remaining) = firstOut
           secondOut <- that.matchSegments(remaining)
           PathMatchOutput(u, lastRemaining) = secondOut
-        } yield PathMatchOutput(ev(t, u), lastRemaining),
-      (out: ev.Out) => {
-        val (t, u) = ev.unapply(out)
+        } yield PathMatchOutput(c.compose(t, u), lastRemaining),
+      (out: c.Composed) => {
+        val (t, u) = c.unapply(out)
 
         this.createSegments(t) ++ that.createSegments(u)
       }

url-dsl/src/main/scala/urldsl/language/PathSegmentWithQueryParams.scala

@@ -1,5 +1,6 @@
 package urldsl.language
 
+import app.tulz.tuplez.Composition
 import urldsl.url.{UrlStringDecoder, UrlStringGenerator, UrlStringParserGenerator}
 import urldsl.vocabulary._
 
@@ -74,12 +75,12 @@ final class PathSegmentWithQueryParams[PathType, +PathError, ParamsType, +Params
 
   def &[OtherParamsType, ParamsError1 >: ParamsError](otherParams: QueryParameters[OtherParamsType, ParamsError1])(
       implicit
-      ev: Tupler[ParamsType, OtherParamsType]
-  ): PathSegmentWithQueryParams[PathType, PathError, ev.Out, ParamsError1] =
-    new PathSegmentWithQueryParams[PathType, PathError, ev.Out, ParamsError1](
+      c: Composition[ParamsType, OtherParamsType]
+  ): PathSegmentWithQueryParams[PathType, PathError, c.Composed, ParamsError1] =
+    new PathSegmentWithQueryParams[PathType, PathError, c.Composed, ParamsError1](
       pathSegment,
       (queryParams & otherParams)
-        .asInstanceOf[QueryParameters[ev.Out, ParamsError1]] // not necessary but IntelliJ complains.
+        .asInstanceOf[QueryParameters[c.Composed, ParamsError1]] // not necessary but IntelliJ complains.
     )
 
   def withFragment[FragmentType, FragmentError](

url-dsl/src/main/scala/urldsl/language/QueryParameters.scala

@@ -1,5 +1,6 @@
 package urldsl.language
 
+import app.tulz.tuplez.Composition
 import urldsl.errors.{DummyError, ParamMatchingError, SimpleParamMatchingError}
 import urldsl.url.{UrlStringDecoder, UrlStringGenerator, UrlStringParserGenerator}
 import urldsl.vocabulary._
@@ -59,24 +60,24 @@ trait QueryParameters[Q, +A] extends UrlPart[Q, A] {
     createParamsString(q, encoder)
 
   /**
-    * Adds `that` QueryParameters to `this` one, "tupling" the returned type with the implicit [[urldsl.language.Tupler]]
+    * Adds `that` QueryParameters to `this` one, "tupling" the returned type with the implicit [[Composition]]
     *
     * The matching and writing of strings is functionally commutative under `&`, but the returned type `Q` is not. So,
     * if you have two parameters, one matching an Int and the other one a String, depending on the order in which `&` is
     * called, you can end up with "Q = (Int, String)" or "Q = (String, Int)". This property is called
     * "QuasiCommutativity" in the tests.
     */
-  final def &[R, A1 >: A](that: QueryParameters[R, A1])(implicit ev: Tupler[Q, R]): QueryParameters[ev.Out, A1] =
-    factory[ev.Out, A1](
+  final def &[R, A1 >: A](that: QueryParameters[R, A1])(implicit c: Composition[Q, R]): QueryParameters[c.Composed, A1] =
+    factory[c.Composed, A1](
       (params: Map[String, Param]) =>
         for {
           firstMatch <- this.matchParams(params)
           ParamMatchOutput(q, remainingParams) = firstMatch
           secondMatch <- that.matchParams(remainingParams)
           ParamMatchOutput(r, finalRemainingParams) = secondMatch
-        } yield ParamMatchOutput(ev(q, r), finalRemainingParams),
-      (out: ev.Out) => {
-        val (q, r) = ev.unapply(out)
+        } yield ParamMatchOutput(c.compose(q, r), finalRemainingParams),
+      (out: c.Composed) => {
+        val (q, r) = c.unapply(out)
         this.createParams(q) ++ that.createParams(r)
       }
     )

url-dsl/src/main/scala/urldsl/language/Tupler.scala

@@ -132,6 +132,9 @@ final class PathSegmentExamples extends AnyFlatSpec with Matchers {
       )
     )
 
+    /** Flattening of int-tuple segment with [[app.tulz.tuplez.Composition]] */
+    (root / segment[String] / segment[(Int, Int)] / "hey").matchPath("hello/22-33/hey") should be(Right("hello", 22, 33))
+
   }
 
   "Some generating examples" should "work" in {
@@ -143,6 +146,8 @@ final class PathSegmentExamples extends AnyFlatSpec with Matchers {
       */
     (root / segment[String] / segment[Int] / "hey").createPart(("hello", 22)) should be("hello/22/hey")
 
+    /** Flattening of int-tuple segment with [[app.tulz.tuplez.Composition]] */
+    (root / segment[String] / segment[(Int, Int)] / "hey").createPart(("hello", 22, 33)) should be("hello/22-33/hey")
   }
 
 }