initial commit

Author: antoine

.gitignore

@@ -0,0 +1,12 @@
+target
+
+.DS_Store
+.idea
+
+.bloop
+.metals
+
+project/target
+project/.bloop
+
+*/target

.scalafmt.conf

@@ -0,0 +1,5 @@
+version = 2.0.0-RC5
+
+maxColumn = 120
+
+align.openParenCallSite = false

build.sbt

@@ -0,0 +1,12 @@
+name := "UrlDSL"
+
+version := "0.1"
+
+scalaVersion := "2.13.1"
+
+scalacOptions ++= Seq("-feature", "-deprecation")
+
+libraryDependencies ++= Seq(
+  "org.scalatest" %% "scalatest" % "3.1.0" % "test",
+  "org.scalacheck" %% "scalacheck" % "1.14.1" % "test"
+)

project/build.properties

@@ -0,0 +1 @@
+sbt.version = 1.3.6

project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.0.0")

src/main/scala/urldsl/errors/DummyError.scala

@@ -0,0 +1,35 @@
+package urldsl.errors
+import urldsl.vocabulary.Segment
+
+/**
+  * Error type with only one instance, for when you only care about knowing whether the error exists.
+  */
+sealed trait DummyError
+
+object DummyError {
+
+  final val dummyError: DummyError = new DummyError {}
+
+  implicit final lazy val dummyErrorIsParamMatchingError: ParamMatchingError[DummyError] =
+    new ParamMatchingError[DummyError] {
+      def missingParameterError(paramName: String): DummyError = dummyError
+
+      def fromThrowable(throwable: Throwable): DummyError = dummyError
+    }
+
+  implicit final lazy val dummyErrorIsPathMatchingError: PathMatchingError[DummyError] =
+    new PathMatchingError[DummyError] {
+      def malformed(str: String): DummyError = dummyError
+
+      def endOfSegmentRequired(remainingSegments: List[Segment]): DummyError = dummyError
+
+      def wrongValue(expected: String, actual: String): DummyError = dummyError
+
+      def missingSegment: DummyError = dummyError
+
+      def fromThrowable(throwable: Throwable): DummyError = dummyError
+    }
+
+  implicit final lazy val dummyErrorIsFromThrowable: ErrorFromThrowable[DummyError] = (_: Throwable) => dummyError
+
+}

src/main/scala/urldsl/errors/ErrorFromThrowable.scala

@@ -0,0 +1,13 @@
+package urldsl.errors
+
+/**
+  * You can implement this trait for your own error type A, and give a implicit instance in order to use the
+  * functionality requiring it, e.g., in [[urldsl.vocabulary.FromString]].
+  *
+  * @tparam A tye type of your error.
+  */
+trait ErrorFromThrowable[A] {
+
+  def fromThrowable(throwable: Throwable): A
+
+}

src/main/scala/urldsl/errors/ParamMatchingError.scala

@@ -0,0 +1,14 @@
+package urldsl.errors
+
+/**
+  * You can implement this trait for your own error type `A`, and provide an implicit instance in the companion object of
+  * `A` in order to use all pre-defined [[urldsl.language.QueryParameters]].
+  *
+  * @example
+  *          See implementations of [[DummyError]] and [[SimpleParamMatchingError]]
+  *
+  * @tparam A the type of your error.
+  */
+trait ParamMatchingError[A] {
+  def missingParameterError(paramName: String): A
+}

src/main/scala/urldsl/errors/PathMatchingError.scala

@@ -0,0 +1,21 @@
+package urldsl.errors
+
+import urldsl.vocabulary.Segment
+
+/**
+  * You can implement this trait for your own error type `A`, a giving an implicit instance in the companion object of
+  * `A` so that it is available for all pre-defined [[urldsl.language.PathSegment]].
+  *
+  * @example
+  *          See implementations of [[DummyError]] or [[SimpleParamMatchingError]]
+  *
+  * @tparam A type of the error.
+  */
+trait PathMatchingError[A] {
+
+  def malformed(str: String): A
+  def endOfSegmentRequired(remainingSegments: List[Segment]): A
+  def wrongValue(expected: String, actual: String): A
+  def missingSegment: A
+
+}

src/main/scala/urldsl/errors/SimpleParamMatchingError.scala

@@ -0,0 +1,19 @@
+package urldsl.errors
+
+sealed trait SimpleParamMatchingError
+
+/**
+  * An implementation of [[ParamMatchingError]] that simply wraps the trigger of the error inside its components.
+  */
+object SimpleParamMatchingError {
+
+  case class MissingParameterError(paramName: String) extends SimpleParamMatchingError
+  case class FromThrowable(throwable: Throwable) extends SimpleParamMatchingError
+
+  implicit lazy val itIsParamMatchingError: ParamMatchingError[SimpleParamMatchingError] =
+    (paramName: String) => MissingParameterError(paramName)
+
+  implicit lazy val simpleParamMatchingErrorIsFromThrowable: ErrorFromThrowable[SimpleParamMatchingError] =
+    (throwable: Throwable) => FromThrowable(throwable)
+
+}

src/main/scala/urldsl/errors/SimplePathMatchingError.scala

@@ -0,0 +1,30 @@
+package urldsl.errors
+
+import urldsl.vocabulary.Segment
+
+sealed trait SimplePathMatchingError
+
+object SimplePathMatchingError {
+
+  final case class MalformedInt(str: String) extends SimplePathMatchingError
+  final case class EndOfSegmentRequired(remainingSegments: Seq[Segment]) extends SimplePathMatchingError
+  final case class WrongValue(expected: String, received: String) extends SimplePathMatchingError
+  final case object MissingSegment extends SimplePathMatchingError
+  final case class SimpleError(reason: String) extends SimplePathMatchingError
+
+  implicit lazy val pathMatchingError: PathMatchingError[SimplePathMatchingError] =
+    new PathMatchingError[SimplePathMatchingError] {
+      def malformed(str: String): SimplePathMatchingError = MalformedInt(str)
+
+      def endOfSegmentRequired(remainingSegments: List[Segment]): SimplePathMatchingError =
+        EndOfSegmentRequired(remainingSegments)
+
+      def wrongValue(expected: String, actual: String): SimplePathMatchingError = WrongValue(expected, actual)
+
+      def missingSegment: SimplePathMatchingError = MissingSegment
+    }
+
+  implicit lazy val errorFromThrowable: ErrorFromThrowable[SimplePathMatchingError] = (throwable: Throwable) =>
+    SimpleError(throwable.getMessage)
+
+}