From 76ffd78ce33c5221266eb427c913b188af1ceccd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Sowa?= Date: Mon, 15 Jul 2024 18:02:22 +0200 Subject: [PATCH 1/6] Basic support for Slick 3.5.x --- build.sbt | 15 +- .../kebs/examples/EnumValueColumnType.scala | 4 +- .../kebs/examples/HStoreColumnType.scala | 4 +- .../examples/HStoreExtensionMethods.scala | 4 +- .../kebs/examples/ListValueCommonType.scala | 4 +- .../kebs/examples/SlickTaggedExample.scala | 4 +- .../kebs/slick/BasicSlickSupport.scala | 274 ++++++++++++++++++ .../scala/pl/iterators/kebs/slick/Kebs.scala | 174 ----------- .../kebs/slick/enums/KebsEnums.scala | 42 --- .../iterators/kebs/slick/enums/package.scala | 9 - .../pl/iterators/kebs/slick/package.scala | 3 - .../SlickMappedColumnTypeTests.scala | 17 +- .../SlickMappedColumnTypeTests.scala | 97 +++++++ .../slick/arrays/ListIsomorphismTest.scala | 41 --- .../arrays/SlickPgArrayColumnTypeTests.scala | 34 +-- .../kebs/slick/arrays/SlickPgArrayTests.scala | 7 +- .../CaseClassIsomorphismTests.scala | 56 ---- .../kebs/slick/caseclasses/SlickPgTests.scala | 11 +- .../slick/enums/EnumIsomorphismTests.scala | 53 ---- .../SlickMappedEnumColumnTypeTests.scala | 25 +- .../SlickMappedValueEnumColumnTypeTests.scala | 10 +- .../enums/ValueEnumIsomorphismTests.scala | 33 --- .../slick/hstore/MapIsomorphismTest.scala | 150 ---------- .../hstore/SlickPgHstoreColumnTypeTests.scala | 7 +- .../slick/hstore/SlickPgHstoreTests.scala | 7 +- .../pl/iterators/kebs/tag/meta/tagged.scala | 4 +- .../kebs/tag/meta/SprayKebsIssue47Test.scala | 1 + .../kebs/tagged/slick/SlickSupport.scala | 8 - .../tagged/slick/TaggedSlickSupport.scala | 12 + .../iterators/kebs/tagged/slick/package.scala | 3 - .../scala/SlickTaggedColumnTypeTests.scala | 16 +- .../scala/TaggedTypeIsomorphismTests.scala | 28 -- 32 files changed, 485 insertions(+), 672 deletions(-) create mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala delete mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala delete mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala delete mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/enums/package.scala delete mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/package.scala rename slick/src/test/{scala => scala-2}/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala (83%) create mode 100644 slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala delete mode 100644 slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala delete mode 100644 slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala delete mode 100644 slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala delete mode 100644 slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala delete mode 100644 slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala delete mode 100644 tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala create mode 100644 tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/TaggedSlickSupport.scala delete mode 100644 tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/package.scala delete mode 100644 tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala diff --git a/build.sbt b/build.sbt index 1395b036..4b6cb643 100644 --- a/build.sbt +++ b/build.sbt @@ -15,7 +15,7 @@ lazy val baseSettings = Seq( organizationName := "Iterators", organizationHomepage := Some(url("https://iterato.rs")), homepage := Some(url("https://github.com/theiterators/kebs")), - scalacOptions ++= Seq("-deprecation", "-unchecked", "-feature", "-encoding", "utf8", "Xsource:3") ++ (if (scalaVersion.value.startsWith("3")) Seq("-Xmax-inlines", "64") else Seq.empty), + scalacOptions ++= Seq("-deprecation", "-unchecked", "-feature", "-encoding", "utf8") ++ (if (scalaVersion.value.startsWith("3")) Seq("-Xmax-inlines", "64", "-Yretain-trees") else Seq("-Xsource:3")), ) lazy val commonMacroSettings = baseSettings ++ Seq( @@ -99,10 +99,10 @@ def paradiseFlag(scalaVersion: String): Seq[String] = val scalaTest = Def.setting("org.scalatest" %%% "scalatest" % "3.2.17") val scalaCheck = Def.setting("org.scalacheck" %%% "scalacheck" % "1.17.0") -val slick = "com.typesafe.slick" %% "slick" % "3.4.1" +val slick = "com.typesafe.slick" %% "slick" % "3.5.1" val optionalSlick = optional(slick) val playJson = "org.playframework" %% "play-json" % "3.0.4" -val slickPg = "com.github.tminglei" %% "slick-pg" % "0.21.1" +val slickPg = "com.github.tminglei" %% "slick-pg" % "0.22.2" val doobie = "org.tpolecat" %% "doobie-core" % "1.0.0-RC4" val doobiePg = "org.tpolecat" %% "doobie-postgres" % "1.0.0-RC4" val sprayJson = "io.spray" %% "spray-json" % "1.3.6" @@ -171,8 +171,8 @@ lazy val commonSettings = baseSettings ++ Seq( ) lazy val slickSettings = commonSettings ++ Seq( - libraryDependencies += slick.cross(CrossVersion.for3Use2_13), - libraryDependencies += (slickPg % "test").cross(CrossVersion.for3Use2_13), + libraryDependencies += slick, + libraryDependencies += (slickPg % "test"), libraryDependencies += (enumeratum % "test") ) @@ -263,14 +263,14 @@ lazy val scalacheckSettings = commonSettings ++ Seq( else Nil)) lazy val taggedSettings = commonSettings ++ Seq( - libraryDependencies += optionalSlick.cross(CrossVersion.for3Use2_13), + libraryDependencies += optionalSlick, libraryDependencies += optional(circe) ) lazy val opaqueSettings = commonSettings lazy val examplesSettings = commonSettings ++ Seq( - libraryDependencies += slickPg.cross(CrossVersion.for3Use2_13), + libraryDependencies += slickPg, libraryDependencies += circeParser, libraryDependencies ++= enumeratumInExamples, libraryDependencies ++= pekkoHttpInExamples, @@ -301,7 +301,6 @@ lazy val slickSupport = project .dependsOn(core.jvm, enumeratumSupport, instances % "test -> test") .settings(slickSettings*) .settings(publishSettings*) - .settings(disableScala(List("3"))) .settings( name := "slick", description := "Library to eliminate the boilerplate code that comes with the use of Slick", diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala b/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala index 458a3930..c8ba4021 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala @@ -98,11 +98,11 @@ object EnumValueColumnType { object AfterKebsTraitStyle { - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport object MyPostgresProfile extends ExPostgresProfile { override val api: APIWithKebsAndEnums = new APIWithKebsAndEnums {} - trait APIWithKebsAndEnums extends super.API with Kebs with KebsEnums.Lowercase + trait APIWithKebsAndEnums extends super.API with BasicSlickSupport with KebsEnums.Lowercase } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala index 96d6271c..2820e667 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala @@ -73,11 +73,11 @@ object HStoreColumnType { object AfterKebs { import pl.iterators.kebs.circe.instances.time.YearMonthString - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport { override val api: APIWithHstore = new APIWithHstore {} - trait APIWithHstore extends super.API with HStoreImplicits with Kebs with YearMonthString + trait APIWithHstore extends super.API with HStoreImplicits with BasicSlickSupport with YearMonthString } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala index 0af45f93..7ecb4af5 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala @@ -49,11 +49,11 @@ object HStoreExtensionMethods { object AfterKebs { import pl.iterators.kebs.circe.instances.time.YearMonthString - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport with PgArraySupport { override val api: APIWithHstore = new APIWithHstore {} - trait APIWithHstore extends super.API with HStoreImplicits with ArrayImplicits with Kebs with YearMonthString + trait APIWithHstore extends super.API with HStoreImplicits with ArrayImplicits with BasicSlickSupport with YearMonthString } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala b/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala index 0edbb26f..0cc22fa9 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala @@ -47,10 +47,10 @@ object ListValueCommonType { object AfterKebsTraitStyle { - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport object MyPostgresProfile extends ExPostgresProfile with PgArraySupport { override val api: APIWithArraysAndKebs = new APIWithArraysAndKebs {} - trait APIWithArraysAndKebs extends super.API with ArrayImplicits with Kebs + trait APIWithArraysAndKebs extends super.API with ArrayImplicits with BasicSlickSupport } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/SlickTaggedExample.scala b/examples/src/main/scala/pl/iterators/kebs/examples/SlickTaggedExample.scala index a703d8d3..0db482d3 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/SlickTaggedExample.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/SlickTaggedExample.scala @@ -3,9 +3,9 @@ package pl.iterators.kebs.examples import slick.jdbc.PostgresProfile.api._ import slick.lifted.ProvenShape import pl.iterators.kebs.tagged._ -import pl.iterators.kebs.tagged.slick.SlickSupport +import pl.iterators.kebs.tagged.slick.TaggedSlickSupport -object SlickTaggedExample extends SlickSupport { +object SlickTaggedExample extends TaggedSlickSupport { trait UserIdTag type UserId = Long @@ UserIdTag diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala b/slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala new file mode 100644 index 00000000..fbc84157 --- /dev/null +++ b/slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala @@ -0,0 +1,274 @@ +package pl.iterators.kebs.slick + +import pl.iterators.kebs.core.enums.{EnumLike, ValueEnumLike, ValueEnumLikeEntry} +import pl.iterators.kebs.core.instances.InstanceConverter +import pl.iterators.kebs.core.macros.ValueClassLike +import pl.iterators.kebs.slick.hstore.KebsHStoreColumnExtensionMethods +import slick.ast.{BaseTypedType, NumericTypedType} +import slick.jdbc.{JdbcProfile, JdbcType} +import slick.lifted._ + +import scala.language.implicitConversions +import scala.reflect.ClassTag + +trait KebsColumnExtensionMethods { + implicit def stringValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[CC] = + new StringColumnExtensionMethods[CC](rep) + implicit def stringValueOptionColumnExt[CC](rep: Rep[Option[CC]])( + implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[Option[CC]] = new StringColumnExtensionMethods[Option[CC]](rep) + implicit def numericValueColumnExt[CC, B](rep: Rep[CC])( + implicit ev1: ValueClassLike[CC, B], + ev2: BaseTypedType[B] with NumericTypedType): BaseNumericColumnExtensionMethods[CC] = new BaseNumericColumnExtensionMethods[CC](rep) + implicit def numericValueOptionColumnExt[CC, B](rep: Rep[Option[CC]])( + implicit ev1: ValueClassLike[CC, B], + ev2: BaseTypedType[B] with NumericTypedType): OptionNumericColumnExtensionMethods[CC] = + new OptionNumericColumnExtensionMethods[CC](rep) + implicit def booleanValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[CC] = + new BooleanColumnExtensionMethods[CC](rep) + implicit def booleanValueOptionColumnExt[CC](rep: Rep[Option[CC]])( + implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[Option[CC]] = + new BooleanColumnExtensionMethods[Option[CC]](rep) + + implicit def hstoreColumnExt[KEY, VALUE](c: Rep[Map[KEY, VALUE]])( + implicit tm0: JdbcType[KEY], + tm1: JdbcType[VALUE], + tm2: JdbcType[List[KEY]], + tm3: JdbcType[List[VALUE]], + tm4: JdbcType[Map[KEY, VALUE]] + ): KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]] = + new KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]](c) + + @inline implicit def getCCOptionMapper2TT_1[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, B2, BR] = + OptionMapper2.plain.asInstanceOf[OptionMapper2[B1, B2, BR, CC, B2, BR]] + @inline implicit def getCCOptionMapper2TT_2[B1, B2, BR, CC](implicit ev: ValueClassLike[CC, B2]): OptionMapper2[CC, CC, BR, CC, B2, BR] = + OptionMapper2.plain.asInstanceOf[OptionMapper2[CC, CC, BR, CC, B2, BR]] + @inline implicit def getCCOptionMapper2TO[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]] = + OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]]] + @inline implicit def getCCOptionMapper2OT[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]] = + OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]]] + @inline implicit def getCCOptionMapper2OO[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]] = + OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]]] +} + +trait BasicSlickSupport { this: JdbcProfile => + trait BasicSlickImplicits extends KebsColumnExtensionMethods { + implicit final def intMapValueColumnType(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, String]] = MappedColumnType.base[Map[Int, String], Map[String, String]]( + _.map { case (int, str) => (int.toString, str) }, + _.map { case (str1, str2) => (str1.toInt, str2) } + ) + + implicit final def longMapValueColumnType(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, String]] = MappedColumnType.base[Map[Long, String], Map[String, String]]( + _.map { case (long, str) => (long.toString, str) }, + _.map { case (str1, str2) => (str1.toLong, str2) } + ) + + implicit final def boolMapValueColumnType(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, String]] = MappedColumnType.base[Map[Boolean, String], Map[String, String]]( + _.map { case (bool, str) => (bool.toString, str) }, + _.map { case (str1, str2) => (str1.toBoolean, str2) } + ) + + implicit final def intMapValueColumnType1(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Int]] = MappedColumnType.base[Map[String, Int], Map[String, String]]( + _.map { case (str, int) => (str, int.toString) }, + _.map { case (str, str1) => (str, str1.toInt) } + ) + + implicit final def longMapValueColumnType1(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Long]] = MappedColumnType.base[Map[String, Long], Map[String, String]]( + _.map { case (str, long) => (str, long.toString) }, + _.map { case (str, str1) => (str, str1.toLong) } + ) + + implicit final def boolMapValueColumnType1(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Boolean]] = MappedColumnType.base[Map[String, Boolean], Map[String, String]]( + _.map { case (str, bool) => (str, bool.toString) }, + _.map { case (str, str1) => (str, str1.toBoolean) } + ) + } + + trait ValueClassLikeImplicits { + implicit def valueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], bct: BaseColumnType[B], cls: ClassTag[CC]): BaseColumnType[CC] = + MappedColumnType.base[CC, B](rep1.unapply, rep1.apply) + + implicit def listValueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], bct: BaseColumnType[List[B]], cls: ClassTag[CC]): BaseColumnType[List[CC]] = + MappedColumnType.base[List[CC], List[B]](_.map(rep1.unapply), _.map(rep1.apply)) + + implicit def hstoreColumnType[CC1, CC2, A, B]( + implicit rep1: ValueClassLike[CC1, A], + rep2: ValueClassLike[CC2, B], + bct: BaseColumnType[Map[A, B]] + ): BaseColumnType[Map[CC1, CC2]] = + MappedColumnType.base[Map[CC1, CC2], Map[A, B]](_.map { case (cc1, cc2) => (rep1.unapply(cc1), rep2.unapply(cc2)) }, + _.map { case (a, b) => (rep1.apply(a), rep2.apply(b)) }) + + implicit def hstoreColumnType1[CC1, A, B]( + implicit rep1: ValueClassLike[CC1, A], + rep2: EnumLike[B], + bct: BaseColumnType[Map[A, String]] + ): BaseColumnType[Map[CC1, B]] = + MappedColumnType.base[Map[CC1, B], Map[A, String]](_.map { case (cc1, b) => (rep1.unapply(cc1), b.toString) }, // TODO: casing + _.map { case (a, str) => (rep1.apply(a), rep2.withName(str)) }) + + implicit def hstoreColumnType2[CC2, A, B]( + implicit rep1: EnumLike[A], + rep2: ValueClassLike[CC2, B], + bct: BaseColumnType[Map[String, B]] + ): BaseColumnType[Map[A, CC2]] = + MappedColumnType.base[Map[A, CC2], Map[String, B]](_.map { case (a, cc2) => (a.toString, rep2.unapply(cc2)) }, + _.map { case (str, cc2) => (rep1.withName(str), rep2.apply(cc2)) }) + + implicit def hstoreColumnType3[CC1, A, B]( + implicit rep1: ValueClassLike[CC1, A], + rep2: EnumLike[B], + bct: BaseColumnType[Map[A, String]] + ): BaseColumnType[Map[CC1, B]] = + MappedColumnType.base[Map[CC1, B], Map[A, String]](_.map { case (cc1, b) => (rep1.unapply(cc1), b.toString) }, // TODO: casing + _.map { case (a, str) => (rep1.apply(a), rep2.withName(str)) }) + } + + trait InstanceConverterImplicits { + implicit def valueTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[B], cls: ClassTag[CC]): BaseColumnType[CC] = + MappedColumnType.base[CC, B](ico.encode, ico.decode) + + implicit def listTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[List[B]], cls: ClassTag[CC]): BaseColumnType[List[CC]] = + MappedColumnType.base[List[CC], List[B]](_.map(ico.encode), _.map(ico.decode)) + + implicit def seqTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[Seq[B]], cls: ClassTag[CC]): BaseColumnType[Seq[CC]] = { + MappedColumnType.base[Seq[CC], Seq[B]](_.map(ico.encode), _.map(ico.decode)) + } + + def instancesIsoMapVal[Obj, Value, MapVal](comap1: String => Value, comap2: String => MapVal)( + implicit ico: InstanceConverter[Obj, Value], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, MapVal]] = + MappedColumnType.base[Map[Obj, MapVal], Map[String, String]]( + _.map { case (obj, mapval) => (ico.encode(obj).toString, mapval.toString) }, + _.map { case (str1, str2) => (ico.decode(comap1(str1)), comap2(str2)) } + ) + + def instancesIsoMapKey[Obj, Value, MapKey](comap1: String => Value, comap2: String => MapKey)( + implicit ico: InstanceConverter[Obj, Value], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[MapKey, Obj]] = + MappedColumnType.base[Map[MapKey, Obj], Map[String, String]]( + _.map { case (mapkey, obj) => (mapkey.toString, ico.encode(obj).toString) }, + _.map { case (str1, str2) => (comap2(str1), ico.decode(comap1(str2))) } + ) + + implicit def instancesIsoObj2Str[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, String]] = + instancesIsoMapVal[Obj, String, String](identity[String], identity[String]) + + implicit def instancesIsoObj2Str1[Obj]( + implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Obj]] = + instancesIsoMapKey[Obj, String, String](identity[String], identity[String]) + + implicit def instancesIsoObj2Str2[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Int]] = + instancesIsoMapVal[Obj, String, Int](identity[String], _.toInt) + + implicit def instancesIsoObj2Str3[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, Obj]] = + instancesIsoMapKey[Obj, String, Int](identity[String], _.toInt) + + implicit def instancesIsoObj2Str4[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Long]] = + instancesIsoMapVal[Obj, String, Long](identity[String], _.toLong) + + implicit def instancesIsoObj2Str5[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, Obj]] = + instancesIsoMapKey[Obj, String, Long](identity[String], _.toLong) + + implicit def instancesIsoObj2Str6[Obj]( + implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Boolean]] = + instancesIsoMapVal[Obj, String, Boolean](identity[String], _.toBoolean) + + implicit def instancesIsoObj2Str7[Obj]( + implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, Obj]] = + instancesIsoMapKey[Obj, String, Boolean](identity[String], _.toBoolean) + + implicit def instancesIsoObj2Int[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, String]] = + instancesIsoMapVal[Obj, Int, String](_.toInt, identity[String]) + + implicit def instancesIsoObj2Int1[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Obj]] = + instancesIsoMapKey[Obj, Int, String](_.toInt, identity[String]) + + implicit def instancesIsoObj2Int2[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Int]] = + instancesIsoMapVal[Obj, Int, Int](_.toInt, _.toInt) + + implicit def instancesIsoObj2Int3[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, Obj]] = + instancesIsoMapKey[Obj, Int, Int](_.toInt, _.toInt) + + implicit def instancesIsoObj2Int4[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Long]] = + instancesIsoMapVal[Obj, Int, Long](_.toInt, _.toLong) + + implicit def instancesIsoObj2Int5[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, Obj]] = + instancesIsoMapKey[Obj, Int, Long](_.toInt, _.toLong) + + implicit def instancesIsoObj2Int6[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Boolean]] = + instancesIsoMapVal[Obj, Int, Boolean](_.toInt, _.toBoolean) + + implicit def instancesIsoObj2Int7[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, Obj]] = + instancesIsoMapKey[Obj, Int, Boolean](_.toInt, _.toBoolean) + + implicit def instancesIsoObj2Long[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, String]] = + instancesIsoMapVal[Obj, Long, String](_.toLong, identity[String]) + + implicit def instancesIsoObj2Long1[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Obj]] = + instancesIsoMapKey[Obj, Long, String](_.toLong, identity[String]) + + implicit def instancesIsoObj2Long2[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Int]] = + instancesIsoMapVal[Obj, Long, Int](_.toLong, _.toInt) + + implicit def instancesIsoObj2Long3[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, Obj]] = + instancesIsoMapKey[Obj, Long, Int](_.toLong, _.toInt) + + implicit def instancesIsoObj2Long4[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Long]] = + instancesIsoMapVal[Obj, Long, Long](_.toLong, _.toLong) + + implicit def instancesIsoObj2Long5[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, Obj]] = + instancesIsoMapKey[Obj, Long, Long](_.toLong, _.toLong) + + implicit def instancesIsoObj2Long6[Obj]( + implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Boolean]] = + instancesIsoMapVal[Obj, Long, Boolean](_.toLong, _.toBoolean) + + implicit def instancesIsoObj2Long7[Obj]( + implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, Obj]] = + instancesIsoMapKey[Obj, Long, Boolean](_.toLong, _.toBoolean) + } + + protected trait SlickEnum { + def enumIsomorphism[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = MappedColumnType.base[E, String](_.toString, `enum`.withName) + + def uppercaseEnumIsomorphism[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = + MappedColumnType.base[E, String](_.toString.toUpperCase, `enum`.withNameUppercaseOnly) + + def lowercaseEnumIsomorphism[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = + MappedColumnType.base[E, String](_.toString.toLowerCase, `enum`.withNameLowercaseOnly) + } + + protected trait SlickValueEnum { + def valueEnumIsomorphism[V, E <: ValueEnumLikeEntry[V]](`enum`: ValueEnumLike[V, E])(implicit bct: BaseColumnType[V], cls: ClassTag[E]): BaseColumnType[E] = + MappedColumnType.base[E, V](_.value, `enum`.withValue) + } + + trait EnumImplicits extends SlickValueEnum with SlickEnum { + implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = enumIsomorphism(ev) + + implicit def valueEnumColumn[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E], bct: BaseColumnType[V], cls: ClassTag[E]): BaseColumnType[E] = + valueEnumIsomorphism(ev) + + implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { + MappedColumnType.base[List[E], List[String]](_.map(_.toString), _.map(ev.withName)) + } + } + + trait LowercaseEnumImplicits extends SlickValueEnum with SlickEnum { + implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = lowercaseEnumIsomorphism(ev) + + implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { + MappedColumnType.base[List[E], List[String]](_.map(_.toString.toLowerCase), _.map(ev.withNameLowercaseOnly)) + } + } + + trait UppercaseEnumImplicits extends SlickValueEnum with SlickEnum { + implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = uppercaseEnumIsomorphism(ev) + + implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { + MappedColumnType.base[List[E], List[String]](_.map(_.toString.toUpperCase), _.map(ev.withNameUppercaseOnly)) + } + } +} diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala b/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala deleted file mode 100644 index a5b8dcb0..00000000 --- a/slick/src/main/scala/pl/iterators/kebs/slick/Kebs.scala +++ /dev/null @@ -1,174 +0,0 @@ -package pl.iterators.kebs.slick - -import pl.iterators.kebs.core.instances.InstanceConverter -import pl.iterators.kebs.core.macros.{CaseClass1ToValueClass, ValueClassLike} -import pl.iterators.kebs.slick.hstore.KebsHStoreColumnExtensionMethods -import slick.ast.{BaseTypedType, NumericTypedType} -import slick.jdbc.JdbcType -import slick.lifted._ - -import scala.language.implicitConversions - -trait KebsColumnExtensionMethods extends CaseClass1ToValueClass { - implicit def stringValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[CC] = - new StringColumnExtensionMethods[CC](rep) - implicit def stringValueOptionColumnExt[CC](rep: Rep[Option[CC]])( - implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[Option[CC]] = new StringColumnExtensionMethods[Option[CC]](rep) - implicit def numericValueColumnExt[CC, B](rep: Rep[CC])( - implicit ev1: ValueClassLike[CC, B], - ev2: BaseTypedType[B] with NumericTypedType): BaseNumericColumnExtensionMethods[CC] = new BaseNumericColumnExtensionMethods[CC](rep) - implicit def numericValueOptionColumnExt[CC, B](rep: Rep[Option[CC]])( - implicit ev1: ValueClassLike[CC, B], - ev2: BaseTypedType[B] with NumericTypedType): OptionNumericColumnExtensionMethods[CC] = - new OptionNumericColumnExtensionMethods[CC](rep) - implicit def booleanValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[CC] = - new BooleanColumnExtensionMethods[CC](rep) - implicit def booleanValueOptionColumnExt[CC](rep: Rep[Option[CC]])( - implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[Option[CC]] = - new BooleanColumnExtensionMethods[Option[CC]](rep) - - implicit def hstoreColumnExt[KEY, VALUE](c: Rep[Map[KEY, VALUE]])( - implicit tm0: JdbcType[KEY], - tm1: JdbcType[VALUE], - tm2: JdbcType[List[KEY]], - tm3: JdbcType[List[VALUE]], - tm4: JdbcType[Map[KEY, VALUE]] - ): KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]] = - new KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]](c) - - @inline implicit def getCCOptionMapper2TT_1[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, B2, BR] = - OptionMapper2.plain.asInstanceOf[OptionMapper2[B1, B2, BR, CC, B2, BR]] - @inline implicit def getCCOptionMapper2TT_2[B1, B2, BR, CC](implicit ev: ValueClassLike[CC, B2]): OptionMapper2[CC, CC, BR, CC, B2, BR] = - OptionMapper2.plain.asInstanceOf[OptionMapper2[CC, CC, BR, CC, B2, BR]] - @inline implicit def getCCOptionMapper2TO[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]] = - OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]]] - @inline implicit def getCCOptionMapper2OT[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]] = - OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]]] - @inline implicit def getCCOptionMapper2OO[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]] = - OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]]] -} - -trait Kebs extends KebsColumnExtensionMethods { - implicit def valueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B]): Isomorphism[CC, B] = - new Isomorphism[CC, B](rep1.unapply, rep1.apply) - implicit def valueTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B]): Isomorphism[CC, B] = - new Isomorphism[CC, B](ico.encode, ico.decode) - implicit def listValueColumnType[CC, B](implicit iso: Isomorphism[CC, B]): Isomorphism[List[CC], List[B]] = - new Isomorphism[List[CC], List[B]](_.map(iso.map), _.map(iso.comap)) - implicit def seqValueColumnType[CC, B](implicit iso: Isomorphism[CC, B]): Isomorphism[Seq[CC], List[B]] = { - new Isomorphism[Seq[CC], List[B]](_.map(iso.map).toList, _.map(iso.comap)) - } - implicit def mapValueColumnType[CC1, CC2, A, B]( - implicit iso1: Isomorphism[CC1, A], - iso2: Isomorphism[CC2, B] - ): Isomorphism[Map[CC1, CC2], Map[A, B]] = - new Isomorphism[Map[CC1, CC2], Map[A, B]]( - _.map { case (cc1, cc2) => (iso1.map(cc1), iso2.map(cc2)) }, - _.map { case (a, b) => (iso1.comap(a), iso2.comap(b)) } - ) - - private class StringMapIsomorphism[A](comap: String => A) - extends Isomorphism[Map[String, A], Map[String, String]]( - _.map { case (str, a) => (str, a.toString) }, - _.map { case (str1, str2) => (str1, comap(str2)) } - ) - implicit final val intMapValueColumnType: Isomorphism[Map[String, Int], Map[String, String]] = - new StringMapIsomorphism[Int](_.toInt) - implicit final val longMapValueColumnType: Isomorphism[Map[String, Long], Map[String, String]] = - new StringMapIsomorphism[Long](_.toLong) - implicit final val boolMapValueColumnType: Isomorphism[Map[String, Boolean], Map[String, String]] = - new StringMapIsomorphism[Boolean](_.toBoolean) - - private class StringValueMapIsomorphism[A](comap: String => A) - extends Isomorphism[Map[A, String], Map[String, String]]( - _.map { case (a, str) => (a.toString, str) }, - _.map { case (str1, str2) => (comap(str1), str2) } - ) - implicit final val intMapValueColumnType1: Isomorphism[Map[Int, String], Map[String, String]] = - new StringValueMapIsomorphism[Int](_.toInt) - implicit final val longMapValueColumnType1: Isomorphism[Map[Long, String], Map[String, String]] = - new StringValueMapIsomorphism[Long](_.toLong) - implicit final val boolMapValueColumnType1: Isomorphism[Map[Boolean, String], Map[String, String]] = - new StringValueMapIsomorphism[Boolean](_.toBoolean) - - implicit def hstoreColumnType[CC1, CC2, A, B]( - implicit iso1: Isomorphism[Map[CC1, CC2], Map[A, B]], - iso2: Isomorphism[Map[A, B], Map[String, String]]): Isomorphism[Map[CC1, CC2], Map[String, String]] = - new Isomorphism[Map[CC1, CC2], Map[String, String]]( - iso1.map andThen iso2.map, - iso2.comap andThen iso1.comap - ) - - def instancesIsoMapVal[Obj, Value, MapVal](comap1: String => Value, comap2: String => MapVal)( - implicit ico: InstanceConverter[Obj, Value]) = - new Isomorphism[Map[Obj, MapVal], Map[String, String]]( - _.map { case (obj, mapval) => (ico.encode(obj).toString, mapval.toString) }, - _.map { case (value, str) => (ico.decode(comap1(value)), comap2(str)) } - ) - def instancesIsoMapKey[Obj, Value, MapKey](comap1: String => Value, comap2: String => MapKey)( - implicit ico: InstanceConverter[Obj, Value]) = - new Isomorphism[Map[MapKey, Obj], Map[String, String]]( - _.map { case (mapkey, obj) => (mapkey.toString, ico.encode(obj).toString) }, - _.map { case (str1, str2) => (comap2(str1), ico.decode(comap1(str2))) } - ) - - implicit def instancesIsoObj2Str[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, String], Map[String, String]] = - instancesIsoMapVal[Obj, String, String](identity[String], identity[String]) - implicit def instancesIsoObj2Str1[Obj]( - implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[String, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, String, String](identity[String], identity[String]) - implicit def instancesIsoObj2Str2[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, Int], Map[String, String]] = - instancesIsoMapVal[Obj, String, Int](identity[String], _.toInt) - implicit def instancesIsoObj2Str3[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Int, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, String, Int](identity[String], _.toInt) - implicit def instancesIsoObj2Str4[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, Long], Map[String, String]] = - instancesIsoMapVal[Obj, String, Long](identity[String], _.toLong) - implicit def instancesIsoObj2Str5[Obj](implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Long, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, String, Long](identity[String], _.toLong) - implicit def instancesIsoObj2Str6[Obj]( - implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Obj, Boolean], Map[String, String]] = - instancesIsoMapVal[Obj, String, Boolean](identity[String], _.toBoolean) - implicit def instancesIsoObj2Str7[Obj]( - implicit ico: InstanceConverter[Obj, String]): Isomorphism[Map[Boolean, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, String, Boolean](identity[String], _.toBoolean) - - implicit def instancesIsoObj2Int[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, String], Map[String, String]] = - instancesIsoMapVal[Obj, Int, String](_.toInt, identity[String]) - implicit def instancesIsoObj2Int1[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[String, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Int, String](_.toInt, identity[String]) - implicit def instancesIsoObj2Int2[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, Int], Map[String, String]] = - instancesIsoMapVal[Obj, Int, Int](_.toInt, _.toInt) - implicit def instancesIsoObj2Int3[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Int, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Int, Int](_.toInt, _.toInt) - implicit def instancesIsoObj2Int4[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, Long], Map[String, String]] = - instancesIsoMapVal[Obj, Int, Long](_.toInt, _.toLong) - implicit def instancesIsoObj2Int5[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Long, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Int, Long](_.toInt, _.toLong) - implicit def instancesIsoObj2Int6[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Obj, Boolean], Map[String, String]] = - instancesIsoMapVal[Obj, Int, Boolean](_.toInt, _.toBoolean) - implicit def instancesIsoObj2Int7[Obj](implicit ico: InstanceConverter[Obj, Int]): Isomorphism[Map[Boolean, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Int, Boolean](_.toInt, _.toBoolean) - - implicit def instancesIsoObj2Long[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, String], Map[String, String]] = - instancesIsoMapVal[Obj, Long, String](_.toLong, identity[String]) - implicit def instancesIsoObj2Long1[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[String, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Long, String](_.toLong, identity[String]) - implicit def instancesIsoObj2Long2[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, Int], Map[String, String]] = - instancesIsoMapVal[Obj, Long, Int](_.toLong, _.toInt) - implicit def instancesIsoObj2Long3[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Int, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Long, Int](_.toLong, _.toInt) - implicit def instancesIsoObj2Long4[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, Long], Map[String, String]] = - instancesIsoMapVal[Obj, Long, Long](_.toLong, _.toLong) - implicit def instancesIsoObj2Long5[Obj](implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Long, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Long, Long](_.toLong, _.toLong) - implicit def instancesIsoObj2Long6[Obj]( - implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Obj, Boolean], Map[String, String]] = - instancesIsoMapVal[Obj, Long, Boolean](_.toLong, _.toBoolean) - implicit def instancesIsoObj2Long7[Obj]( - implicit ico: InstanceConverter[Obj, Long]): Isomorphism[Map[Boolean, Obj], Map[String, String]] = - instancesIsoMapKey[Obj, Long, Boolean](_.toLong, _.toBoolean) -} diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala b/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala deleted file mode 100644 index d9e16975..00000000 --- a/slick/src/main/scala/pl/iterators/kebs/slick/enums/KebsEnums.scala +++ /dev/null @@ -1,42 +0,0 @@ -package pl.iterators.kebs.slick.enums - -import pl.iterators.kebs.core.enums.{EnumLike, ValueEnumLike, ValueEnumLikeEntry} -import slick.lifted.Isomorphism - -trait SlickEnum { - def enumIsomorphism[E](`enum`: EnumLike[E]): Isomorphism[E, String] = new Isomorphism[E, String](_.toString, `enum`.withName) - - def uppercaseEnumIsomorphism[E](`enum`: EnumLike[E]): Isomorphism[E, String] = - new Isomorphism[E, String](_.toString.toUpperCase, `enum`.withNameUppercaseOnly) - - def lowercaseEnumIsomorphism[E](`enum`: EnumLike[E]): Isomorphism[E, String] = - new Isomorphism[E, String](_.toString.toLowerCase, `enum`.withNameLowercaseOnly) - - implicit def enumListColumnType[E](implicit iso: Isomorphism[E, String]): Isomorphism[List[E], List[String]] = - new Isomorphism[List[E], List[String]](_.map(iso.map), _.map(iso.comap)) - - implicit def enumSeqColumnType[E](implicit iso: Isomorphism[E, String]): Isomorphism[Seq[E], List[String]] = - new Isomorphism[Seq[E], List[String]](_.map(iso.map).toList, _.map(iso.comap)) -} - -trait SlickValueEnum { - def valueEnumIsomorphism[V, E <: ValueEnumLikeEntry[V]](`enum`: ValueEnumLike[V, E]): Isomorphism[E, V] = - new Isomorphism[E, V](_.value, `enum`.withValue) -} - -trait KebsEnums extends SlickEnum with SlickValueEnum { - implicit def enumValueColumn[E](implicit ev: EnumLike[E]): Isomorphism[E, String] = enumIsomorphism(ev) - - implicit def valueEnumColumn[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E]): Isomorphism[E, V] = - valueEnumIsomorphism(ev) - - trait Uppercase extends SlickEnum { - implicit def enumValueColumn[E](implicit ev: EnumLike[E]): Isomorphism[E, String] = uppercaseEnumIsomorphism(ev) - } - - trait Lowercase extends SlickEnum { - implicit def enumValueColumn[E](implicit ev: EnumLike[E]): Isomorphism[E, String] = lowercaseEnumIsomorphism(ev) - } -} - -object KebsEnums extends KebsEnums \ No newline at end of file diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/enums/package.scala b/slick/src/main/scala/pl/iterators/kebs/slick/enums/package.scala deleted file mode 100644 index 6a20e2d5..00000000 --- a/slick/src/main/scala/pl/iterators/kebs/slick/enums/package.scala +++ /dev/null @@ -1,9 +0,0 @@ -package pl.iterators.kebs.slick - -package object enums extends KebsEnums { - - object uppercase extends Uppercase - - object lowercase extends Lowercase - -} diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/package.scala b/slick/src/main/scala/pl/iterators/kebs/slick/package.scala deleted file mode 100644 index c3fbccc3..00000000 --- a/slick/src/main/scala/pl/iterators/kebs/slick/package.scala +++ /dev/null @@ -1,3 +0,0 @@ -package pl.iterators.kebs - -package object slick extends Kebs diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala b/slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala similarity index 83% rename from slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala rename to slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala index cbdaab8f..1f9b00e4 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala +++ b/slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala @@ -2,11 +2,18 @@ package pl.iterators.kebs.slick.caseclasses import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass +import pl.iterators.kebs.slick.BasicSlickSupport +import slick.jdbc.PostgresProfile class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers { + object MyPostgresProfile extends PostgresProfile with BasicSlickSupport { + override val api: APITagged = new APITagged {} + trait APITagged extends JdbcAPI with BasicSlickImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass + } + + import MyPostgresProfile.api._ import slick.lifted.ProvenShape - import slick.jdbc.PostgresProfile.api._ - import pl.iterators.kebs._ case class Id(id: Long) case class Row(id: Id, name: String, num: Long) @@ -37,11 +44,13 @@ class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers { | def name = column[String]("name") | def num = column[Long]("num") | - | override def * : ProvenShape[Row] = (id, name, num) <> (Row.tupled, Row.unapply) + | override def * : ProvenShape[Row] = (id, name, num) <> ((Row.apply _).tupled, Row.unapply) | } """.stripMargin should compile } + // for the tests below, Name.unapply (etc.) works fine, Scala 3 is more picky here + test("Slick mapping - one element wrapper") { """ |class OneElement(tag: Tag) extends Table[Name](tag, "ONE_ELEMENT_TABLE") { @@ -56,7 +65,7 @@ class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers { """ |class Matryoshka(tag: Tag) extends Table[WrappedName](tag, "MATRYOSHKA") { | def name = column[Name]("name") - | + | | override def * : ProvenShape[WrappedName] = name <> (WrappedName.apply, WrappedName.unapply) |} """.stripMargin should compile diff --git a/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala b/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala new file mode 100644 index 00000000..cbdbb301 --- /dev/null +++ b/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala @@ -0,0 +1,97 @@ +package pl.iterators.kebs.slick.caseclasses + +import org.scalatest.funsuite.AnyFunSuite +import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass +import pl.iterators.kebs.slick.BasicSlickSupport +import slick.jdbc.PostgresProfile + +class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers { + object MyPostgresProfile extends PostgresProfile with BasicSlickSupport { + override val api: APITagged = new APITagged {} + trait APITagged extends JdbcAPI with BasicSlickImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass + } + + import MyPostgresProfile.api._ + import slick.lifted.ProvenShape + + case class Id(id: Long) + case class Row(id: Id, name: String, num: Long) + case class Name(name: String) + case class WrappedName(name: Name) + + test("MappedColumnType for case classes") { + "implicitly[BaseColumnType[Id]]" should compile + } + + test("Slick mapping") { + """ + |class ATable(tag: Tag) extends Table[(Id, String, Long)](tag, "A_TABLE") { + | def id = column[Id]("id") + | def name = column[String]("name") + | def num = column[Long]("num") + | + | override def * = (id, name, num) + |} + """.stripMargin should compile + } + + test("Slick mapping - mapped projection") { + """ + | + |class ATable(tag: Tag) extends Table[Row](tag, "A_TABLE") { + | def id = column[Id]("id") + | def name = column[String]("name") + | def num = column[Long]("num") + | + | override def * : ProvenShape[Row] = (id, name, num) <> ((Row.apply _).tupled, Row.unapply) + | } + """.stripMargin should compile + } + + // for some reason, Scala 3 requires this weird notation below... + + test("Slick mapping - one element wrapper") { + """ + |class OneElement(tag: Tag) extends Table[Name](tag, "ONE_ELEMENT_TABLE") { + | def name = column[String]("name") + | + | override def * : ProvenShape[Name] = name <> (Name.apply, n => Some(n.name)) + | } + """.stripMargin should compile + } + + test("Slick mapping - matryoshka case 1") { + """ + |class Matryoshka(tag: Tag) extends Table[WrappedName](tag, "MATRYOSHKA") { + | def name = column[Name]("name") + | + | override def * : ProvenShape[WrappedName] = name <> (WrappedName.apply, n => Some(n.name)) + |} + """.stripMargin should compile + } + + test("Slick mapping - matryoshka case 2") { + """ + |class Matryoshka(tag: Tag) extends Table[WrappedName](tag, "MATRYOSHKA") { + | def name = column[Name]("name") + | private def mappedProjection = name <> (WrappedName.apply, n => Some(n.name)) + | + | override def * : ProvenShape[WrappedName] = mappedProjection + | } + """.stripMargin should compile + } + + class NoMapping(id: Long) + + test("Wrong slick mapping") { + """ + |class ATable(tag: Tag) extends Table[(NoMapping, String)](tag, "A_TABLE") { + | def id = column[NoMapping]("id") + | def name = column[String]("name") + | + | override def * = (id, name) + |} + """.stripMargin shouldNot typeCheck + } +} diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala deleted file mode 100644 index c71cf665..00000000 --- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/ListIsomorphismTest.scala +++ /dev/null @@ -1,41 +0,0 @@ -package pl.iterators.kebs.slick.arrays - -import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.matchers.should.Matchers -import pl.iterators.kebs.instances.time.YearMonthString -import slick.lifted.Isomorphism - -class ListIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString { - import pl.iterators.kebs.slick._ - - case class C(a: String) - - test("No ValueClassLike implicits derived") { - import pl.iterators.kebs.core.macros.ValueClassLike - - "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck - "implicitly[ValueClassLike[String, YearMonth]]" shouldNot typeCheck - } - - test("Case class isomorphism implies list isomorphism") { - val iso = implicitly[Isomorphism[List[C], List[String]]] - iso.map(List(C("a"), C("b"))) shouldBe List("a", "b") - iso.comap(List("a", "b")) shouldBe List(C("a"), C("b")) - } - - test("Case class isomorphism implies seq to list isomorphism") { - val iso = implicitly[Isomorphism[Seq[C], List[String]]] - iso.map(Seq(C("a"), C("b"))) shouldBe List("a", "b") - iso.comap(List("a", "b")) shouldBe Seq(C("a"), C("b")) - } - - import java.time.YearMonth - - test("List[Obj[String]] <-> List[String]") { - "val iso = implicitly[Isomorphism[List[YearMonth], List[String]]]" should compile - } - - test("Seq[Obj[String]] <-> List[String]") { - "val iso = implicitly[Isomorphism[Seq[YearMonth], List[String]]]" should compile - } -} diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala index 64cf1cd4..8b008aa4 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala @@ -4,18 +4,18 @@ import com.github.tminglei.slickpg._ import enumeratum.{Enum, EnumEntry} import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass import pl.iterators.kebs.enumeratum.KebsEnumeratum -import pl.iterators.kebs.slick.enums.KebsEnums class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers with KebsEnumeratum { case class Institution(value: Long) case class MarketFinancialProduct(value: String) - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport - object MyPostgresProfile extends ExPostgresProfile with PgArraySupport { + object MyPostgresProfile extends ExPostgresProfile with PgArraySupport with BasicSlickSupport { override val api: APIWithArrays = new APIWithArrays {} - trait APIWithArrays extends super.API with ArrayImplicits with Kebs with KebsEnums + trait APIWithArrays extends ExtPostgresAPI with ArrayImplicits with BasicSlickImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass with EnumImplicits } import MyPostgresProfile.api._ @@ -31,18 +31,6 @@ class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers with KebsEnu """.stripMargin should compile } - test("Seq column type") { - """ - | class SeqTestTable(tag: Tag) extends Table[(Long, Seq[Institution], Option[List[MarketFinancialProduct]])](tag, "SeqTest") { - | def id = column[Long]("id", O.AutoInc, O.PrimaryKey) - | def institutions = column[Seq[Institution]]("institutions") - | def mktFinancialProducts = column[Option[List[MarketFinancialProduct]]]("mktFinancialProducts") - | - | def * = (id, institutions, mktFinancialProducts) - | } - """.stripMargin should compile - } - sealed trait AnEnum extends EnumEntry object AnEnum extends Enum[AnEnum] { case object Something extends AnEnum @@ -52,23 +40,23 @@ class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers with KebsEnu } import enums._ - test("Seq column type with enums") { + test("List column type with enums") { """ - | class EnumSeqTestTable(tag: Tag) extends Table[(Long, Seq[AnEnum])](tag, "EnumSeqTest") { + | class EnumSeqTestTable(tag: Tag) extends Table[(Long, List[AnEnum])](tag, "EnumSeqTest") { | def id = column[Long]("id", O.AutoInc, O.PrimaryKey) - | def enums = column[Seq[AnEnum]]("enums") + | def enums = column[List[AnEnum]]("enums") | | def * = (id, enums) | } """.stripMargin should compile } - test("Seq column type with enums and not enums") { + test("List column type with enums and not enums") { """ - | class EnumSeqTestTable(tag: Tag) extends Table[(Long, Seq[Institution], Seq[AnEnum])](tag, "EnumSeqTest") { + | class EnumSeqTestTable(tag: Tag) extends Table[(Long, List[Institution], List[AnEnum])](tag, "EnumSeqTest") { | def id = column[Long]("id", O.AutoInc, O.PrimaryKey) - | def institutions = column[Seq[Institution]]("institutions") - | def enums = column[Seq[AnEnum]]("enums") + | def institutions = column[List[Institution]]("institutions") + | def enums = column[List[AnEnum]]("enums") | | def * = (id, institutions, enums) | } diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala index cb884501..1cd5a193 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala @@ -3,6 +3,7 @@ package pl.iterators.kebs.slick.arrays import com.github.tminglei.slickpg._ import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.{CaseClass1ToValueClass, ValueClassLike} import slick.lifted.ProvenShape import java.time.YearMonth @@ -10,11 +11,11 @@ import java.util.UUID class SlickPgArrayTests extends AnyFunSuite with Matchers { import pl.iterators.kebs.instances.time.YearMonthString - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport - trait PostgresDriver extends ExPostgresProfile with PgArraySupport { + trait PostgresDriver extends ExPostgresProfile with PgArraySupport with BasicSlickSupport { override val api: ArrayAPI = new ArrayAPI {} - trait ArrayAPI extends super.API with ArrayImplicits with Kebs with YearMonthString + trait ArrayAPI extends ExtPostgresAPI with ArrayImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass with InstanceConverterImplicits with YearMonthString } object PostgresDriver extends PostgresDriver diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala deleted file mode 100644 index 29a24d98..00000000 --- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/CaseClassIsomorphismTests.scala +++ /dev/null @@ -1,56 +0,0 @@ -package pl.iterators.kebs.slick.caseclasses - -import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.matchers.should.Matchers - -class CaseClassIsomorphismTests extends AnyFunSuite with Matchers { - import slick.lifted.Isomorphism - import pl.iterators.kebs._ - - case class Simple1(a: Int) - case class Simple2(a: Option[Int]) - - test("Implicit isomorphism for case class of arity 1") { - val iso = implicitly[Isomorphism[Simple1, Int]] - iso.map(Simple1(10)) shouldBe 10 - iso.comap(10) shouldBe Simple1(10) - } - - test("Implicit isomorphism for case class of arity 1 - parametrized return type") { - val iso = implicitly[Isomorphism[Simple2, Option[Int]]] - iso.map(Simple2(Some(10))) shouldBe Some(10) - iso.comap(Some(10)) shouldBe Simple2(Some(10)) - } - - case class TooBig(a: Int, b: Int) - - test("No isomorphism for case classes of arity > 1") { - "implicitly[Isomorphism[TooBig, _]]" shouldNot typeCheck - } - - case object NoIsoForYou - - test("No isomorphism for case classes of arity == 0") { - "implicitly[Isomorphism[NoIsoForYou.type, _]]" shouldNot typeCheck - } - - class JustAClass(val a: Int) - - test("No isomorphism for ordinary classes") { - "implicitly[Isomorphism[JustAClass, Int]]" shouldNot typeCheck - } - - case class Parametrized[P](a: P) - - test("Implicit isomorphism for parametrized case class of arity 1") { - val iso = implicitly[Isomorphism[Parametrized[Int], Int]] - iso.map(Parametrized(10)) shouldBe 10 - iso.comap(10) shouldBe Parametrized(10) - } - - test("Implicit isomorphism for parametrized case class of arity 1 - unrefined type parameter") { - def iso[P]: Isomorphism[Parametrized[P], P] = implicitly[Isomorphism[Parametrized[P], P]] - iso[Int].map(Parametrized(10)) shouldBe 10 - iso[Option[Int]].comap(Some(10)) shouldBe Parametrized(Some(10)) - } -} diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala index 8b91fcbb..53d942a9 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala @@ -3,21 +3,22 @@ package pl.iterators.kebs.slick.caseclasses import com.github.tminglei.slickpg._ import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass import java.util.UUID class SlickPgTests extends AnyFunSuite with Matchers { - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport import slick.lifted.ProvenShape case class ServiceLineName(name: String) case class Id(id: Int) case class ServiceLine(id: Id, name: ServiceLineName) - trait PostgresDriver extends ExPostgresProfile { - override val api = PostgresApi - object PostgresApi extends API with Kebs + trait PostgresDriver extends ExPostgresProfile with BasicSlickSupport { + override val api: PostgresApi.type = PostgresApi + object PostgresApi extends ExtPostgresAPI with ValueClassLikeImplicits with CaseClass1ToValueClass with BasicSlickImplicits } object PostgresDriver extends PostgresDriver @@ -38,7 +39,7 @@ class SlickPgTests extends AnyFunSuite with Matchers { | def id: Rep[Id] = column[Id]("id", O.PrimaryKey) | def name: Rep[ServiceLineName] = column[ServiceLineName]("name") | - | override def * : ProvenShape[ServiceLine] = (id, name) <> (ServiceLine.tupled, ServiceLine.unapply) + | override def * : ProvenShape[ServiceLine] = (id, name) <> ((ServiceLine.apply _).tupled, ServiceLine.unapply) | } """.stripMargin should compile } diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala deleted file mode 100644 index cdd5fb47..00000000 --- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/EnumIsomorphismTests.scala +++ /dev/null @@ -1,53 +0,0 @@ -package enums - -import enumeratum.{Enum, EnumEntry} -import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.matchers.should.Matchers -import pl.iterators.kebs.core.enums.EnumLike -import slick.lifted.Isomorphism -import pl.iterators.kebs.enumeratum.KebsEnumeratum - -class EnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum { - - sealed trait Greeting extends EnumEntry - - object Greeting extends Enum[Greeting] { - case object Hello extends Greeting - case object GoodBye extends Greeting - case object Hi extends Greeting - case object Bye extends Greeting - - val values = findValues - } - - import Greeting._ - - test("Implicit isomorphism for EnumEntry") { - import pl.iterators.kebs.slick.enums._ - - val iso = implicitly[Isomorphism[Greeting, String]] - iso.map(Hello) shouldBe "Hello" - iso.comap("Hello") shouldBe Hello - } - - test("Implicit isomorphism for EnumEntry - lowercase") { - import pl.iterators.kebs.slick.enums.lowercase._ - - val enumm = new EnumLike[Greeting] { - override def values: Seq[Greeting] = Greeting.values} - - val iso = implicitly[Isomorphism[Greeting, String]] - - iso.map(GoodBye) shouldBe "goodbye" - iso.comap("goodbye") shouldBe GoodBye - } - - test("Implicit isomorphism for EnumEntry - uppercase") { - import pl.iterators.kebs.slick.enums.uppercase._ - - val iso = implicitly[Isomorphism[Greeting, String]] - iso.map(GoodBye) shouldBe "GOODBYE" - iso.comap("GOODBYE") shouldBe GoodBye - } - -} diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala index 0e6bed9d..0957e208 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala @@ -1,13 +1,29 @@ package pl.iterators.kebs.slick.enums +import com.github.tminglei.slickpg.ExPostgresProfile +import com.github.tminglei.slickpg.ExPostgresProfile.ExtPostgresAPI import enumeratum.{Enum, EnumEntry} import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import pl.iterators.kebs.enumeratum.KebsEnumeratum class SlickMappedEnumColumnTypeTests extends AnyFunSuite with Matchers with KebsEnumeratum { - import slick.jdbc.PostgresProfile.api._ - import pl.iterators.kebs.slick.enums._ + import pl.iterators.kebs.slick.BasicSlickSupport + + trait PostgresDriver extends ExPostgresProfile with BasicSlickSupport { + override val api: EnumAPI = new EnumAPI {} + trait EnumAPI extends ExtPostgresAPI with BasicSlickImplicits with ValueClassLikeImplicits with EnumImplicits + } + object PostgresDriver extends PostgresDriver + + abstract class BaseTable[T](tag: BaseTable.Tag, tableName: String) extends BaseTable.driver.Table[T](tag, tableName) { + protected val driver: PostgresDriver = BaseTable.driver + } + + object BaseTable { + protected val driver = PostgresDriver + type Tag = driver.api.Tag + } sealed trait WorkerAccountStatus extends EnumEntry object WorkerAccountStatus extends Enum[WorkerAccountStatus] { @@ -17,13 +33,14 @@ class SlickMappedEnumColumnTypeTests extends AnyFunSuite with Matchers with Kebs override val values = findValues } - + import PostgresDriver.api._ test("MappedColumnType for enum entries") { "implicitly[BaseColumnType[WorkerAccountStatus]]" should compile } test("Slick mapping") { - class ATable(tag: Tag) extends Table[(Long, String, WorkerAccountStatus)](tag, "A_TABLE") { + class ATable(tag: BaseTable.Tag) extends BaseTable[(Long, String, WorkerAccountStatus)](tag, "A_TABLE") { + import driver.api._ def id = column[Long]("id") def name = column[String]("name") def status = column[WorkerAccountStatus]("status") diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala index 6b1c6f6b..a0f75eaa 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala @@ -5,10 +5,16 @@ import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import pl.iterators.kebs.core.enums.ValueEnumLikeEntry import pl.iterators.kebs.enumeratum.KebsValueEnumeratum +import pl.iterators.kebs.slick.BasicSlickSupport +import slick.jdbc.PostgresProfile class SlickMappedValueEnumColumnTypeTests extends AnyFunSuite with Matchers with KebsValueEnumeratum { - import slick.jdbc.PostgresProfile.api._ - import pl.iterators.kebs.slick.enums._ + object MyPostgresProfile extends PostgresProfile with BasicSlickSupport { + override val api: APITagged = new APITagged {} + trait APITagged extends JdbcAPI with EnumImplicits + } + + import MyPostgresProfile.api._ sealed abstract class WorkerAccountStatusInt(val value: Int) extends IntEnumEntry with ValueEnumLikeEntry[Int] object WorkerAccountStatusInt extends IntEnum[WorkerAccountStatusInt] { diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala deleted file mode 100644 index ff6622cc..00000000 --- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/ValueEnumIsomorphismTests.scala +++ /dev/null @@ -1,33 +0,0 @@ -package pl.iterators.kebs.slick.enums - -import enumeratum.values.{IntEnum, IntEnumEntry} -import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.matchers.should.Matchers -import pl.iterators.kebs.core.enums.ValueEnumLikeEntry -import slick.lifted.Isomorphism -import pl.iterators.kebs.enumeratum.KebsEnumeratum - -class ValueEnumIsomorphismTests extends AnyFunSuite with Matchers with KebsEnumeratum { - - sealed abstract class IntGreeting(val value: Int) extends IntEnumEntry with ValueEnumLikeEntry[Int] - - object IntGreeting extends IntEnum[IntGreeting] { - case object Hello extends IntGreeting(0) - case object GoodBye extends IntGreeting(1) - case object Hi extends IntGreeting(2) - case object Bye extends IntGreeting(3) - - val values = findValues - } - - import IntGreeting._ - - test("Implicit isomorphism from ValueEnumEntry") { - import pl.iterators.kebs.slick.enums._ - - val iso = implicitly[Isomorphism[IntGreeting, Int]] - iso.map(Bye) shouldBe 3 - iso.comap(3) shouldBe Bye - } - -} diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala deleted file mode 100644 index 657d8af2..00000000 --- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/MapIsomorphismTest.scala +++ /dev/null @@ -1,150 +0,0 @@ -package pl.iterators.kebs.slick.hstore - -import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.matchers.should.Matchers -import pl.iterators.kebs.instances.time.{DayOfWeekInt, YearMonthString} -import pl.iterators.kebs.instances.time.mixins.InstantEpochMilliLong -import slick.lifted.Isomorphism - -class MapIsomorphismTest extends AnyFunSuite with Matchers with YearMonthString with DayOfWeekInt with InstantEpochMilliLong { - import pl.iterators.kebs.slick._ - - case class StringValue(value: String) - case class IntValue(value: Int) - - test("No ValueClassLike implicits derived") { - import pl.iterators.kebs.core.macros.ValueClassLike - - "implicitly[ValueClassLike[YearMonth, String]]" shouldNot typeCheck - "implicitly[ValueClassLike[String, YearMonth]]" shouldNot typeCheck - "implicitly[ValueClassLike[DayOfWeek, Int]]" shouldNot typeCheck - "implicitly[ValueClassLike[Int, DayOfWeek]]" shouldNot typeCheck - "implicitly[ValueClassLike[Instant, Long]]" shouldNot typeCheck - "implicitly[ValueClassLike[Long, Instant]]" shouldNot typeCheck - } - - test("Case classes isomorphisms implies string to int map isomorphism") { - val iso = implicitly[Isomorphism[Map[StringValue, IntValue], Map[String, Int]]] - iso.map(Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))) shouldBe Map("a" -> 0, "b" -> 1) - iso.comap(Map("a" -> 0, "b" -> 1)) shouldBe Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1)) - } - - test("Case classes isomorphisms implies string to string map isomorphism") { - val iso = implicitly[Isomorphism[Map[StringValue, IntValue], Map[String, String]]] - iso.map(Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1))) shouldBe Map("a" -> "0", "b" -> "1") - iso.comap(Map("a" -> "0", "b" -> "1")) shouldBe Map(StringValue("a") -> IntValue(0), StringValue("b") -> IntValue(1)) - } - - test("Case classes isomorphisms implies int to string map isomorphism") { - val iso = implicitly[Isomorphism[Map[IntValue, StringValue], Map[Int, String]]] - iso.map(Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b"))) shouldBe Map(0 -> "a", 1 -> "b") - iso.comap(Map(0 -> "a", 1 -> "b")) shouldBe Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b")) - } - - test("Case classes isomorphisms implies string to string map isomorphism 2") { - val iso = implicitly[Isomorphism[Map[IntValue, StringValue], Map[String, String]]] - iso.map(Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b"))) shouldBe Map("0" -> "a", "1" -> "b") - iso.comap(Map("0" -> "a", "1" -> "b")) shouldBe Map(IntValue(0) -> StringValue("a"), IntValue(1) -> StringValue("b")) - } - - import java.time.{DayOfWeek, YearMonth, Instant} - - /* InstanceConverter[Obj, String] */ - test("Map[Obj[String], String] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[YearMonth, String], Map[String, String]]]""".stripMargin should compile - } - - test("Map[String, Obj[String]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[String, YearMonth], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[String], Int] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[YearMonth, Int], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Int, Obj[String]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Int, YearMonth], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[String], Long] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[YearMonth, Long], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Long, Obj[String]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Long, YearMonth], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[String], Boolean] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[YearMonth, Boolean], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Boolean, Obj[String]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Boolean, YearMonth], Map[String, String]]]""".stripMargin should compile - } - - /* implicit InstanceConverter[Obj, Int] */ - test("Map[Obj[Int], String] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[DayOfWeek, String], Map[String, String]]]""".stripMargin should compile - } - - test("Map[String, Obj[Int]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[String, DayOfWeek], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[Int], Int] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[DayOfWeek, Int], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Int, Obj[Int]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Int, DayOfWeek], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[Int], Long] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[DayOfWeek, Long], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Long, Obj[Int]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Long, DayOfWeek], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[Int], Boolean] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[DayOfWeek, Boolean], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Boolean, Obj[Int]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Boolean, DayOfWeek], Map[String, String]]]""".stripMargin should compile - } - - /* implicit InstanceConverter[Obj, Long] */ - test("Map[Obj[Long], String] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Instant, String], Map[String, String]]]""".stripMargin should compile - } - - test("Map[String, Obj[Long]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[String, Instant], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[Long], Int] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Instant, Int], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Int, Obj[Long]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Int, Instant], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[Long], Long] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Instant, Long], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Long, Obj[Long]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Long, Instant], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Obj[Long], Boolean] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Instant, Boolean], Map[String, String]]]""".stripMargin should compile - } - - test("Map[Boolean, Obj[Long]] <-> Map[String, String]") { - """val iso = implicitly[Isomorphism[Map[Boolean, Instant], Map[String, String]]]""".stripMargin should compile - } -} diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala index fe8ccaa2..0d86b712 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala @@ -3,16 +3,17 @@ package pl.iterators.kebs.slick.hstore import com.github.tminglei.slickpg._ import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers { import pl.iterators.kebs.instances.time.{DayOfWeekInt, YearMonthString} import pl.iterators.kebs.instances.time.mixins.InstantEpochMilliLong - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport import java.time.{DayOfWeek, YearMonth, Instant} - object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport { + object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport with BasicSlickSupport { override val api: APIWithHStore = new APIWithHStore {} - trait APIWithHStore extends super.API with HStoreImplicits with Kebs with YearMonthString with DayOfWeekInt with InstantEpochMilliLong + trait APIWithHStore extends ExtPostgresAPI with HStoreImplicits with BasicSlickImplicits with InstanceConverterImplicits with YearMonthString with DayOfWeekInt with InstantEpochMilliLong with ValueClassLikeImplicits with CaseClass1ToValueClass } case class CategoryName(name: String) diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala index da17c270..d189b5c3 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala @@ -3,6 +3,7 @@ package pl.iterators.kebs.slick.hstore import com.github.tminglei.slickpg._ import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass import slick.lifted.ProvenShape import java.time.YearMonth @@ -10,11 +11,11 @@ import java.util.UUID class SlickPgHstoreTests extends AnyFunSuite with Matchers { import pl.iterators.kebs.instances.time.YearMonthString - import pl.iterators.kebs.slick.Kebs + import pl.iterators.kebs.slick.BasicSlickSupport - trait PostgresDriver extends ExPostgresProfile with PgArraySupport with PgHStoreSupport { + trait PostgresDriver extends ExPostgresProfile with PgArraySupport with PgHStoreSupport with BasicSlickSupport { override val api: HstoreAPI = new HstoreAPI {} - trait HstoreAPI extends super.API with ArrayImplicits with HStoreImplicits with Kebs with YearMonthString + trait HstoreAPI extends ExtPostgresAPI with ArrayImplicits with HStoreImplicits with BasicSlickImplicits with YearMonthString with ValueClassLikeImplicits with CaseClass1ToValueClass with InstanceConverterImplicits } object PostgresDriver extends PostgresDriver diff --git a/tagged-meta/src/main/scala/pl/iterators/kebs/tag/meta/tagged.scala b/tagged-meta/src/main/scala/pl/iterators/kebs/tag/meta/tagged.scala index ef6cb666..abfb78db 100644 --- a/tagged-meta/src/main/scala/pl/iterators/kebs/tag/meta/tagged.scala +++ b/tagged-meta/src/main/scala/pl/iterators/kebs/tag/meta/tagged.scala @@ -121,9 +121,9 @@ final class macroImpl(val c: whitebox.Context) { val implicitName = TermName(name.decodedName.toString + "ValueClassLike") if (typeParams.isEmpty) - q"implicit val $implicitName = $valueClassLikeInstanceTree" + q"implicit val $implicitName: _root_.pl.iterators.kebs.core.macros.ValueClassLike[$selfType, $baseTypeName] = $valueClassLikeInstanceTree" else - q"implicit def $implicitName[..$typeParams] = $valueClassLikeInstanceTree" + q"implicit def $implicitName[..$typeParams]: _root_.pl.iterators.kebs.core.macros.ValueClassLike[$selfType, $baseTypeName[..$baseParams]] = $valueClassLikeInstanceTree" } private def containsApply(trees: List[Tree]): Boolean = { diff --git a/tagged-meta/src/test/scala/pl/iterators/kebs/tag/meta/SprayKebsIssue47Test.scala b/tagged-meta/src/test/scala/pl/iterators/kebs/tag/meta/SprayKebsIssue47Test.scala index 848c7759..500fa845 100644 --- a/tagged-meta/src/test/scala/pl/iterators/kebs/tag/meta/SprayKebsIssue47Test.scala +++ b/tagged-meta/src/test/scala/pl/iterators/kebs/tag/meta/SprayKebsIssue47Test.scala @@ -9,6 +9,7 @@ import pl.iterators.kebs.tag.meta.tagged import pl.iterators.kebs.tagged._ import util.Properties.versionNumberString import spray.json.{DefaultJsonProtocol, JsonFormat} +import pl.iterators.kebs.core.macros.CaseClass1ToValueClass._ package object domain extends Domain {} diff --git a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala b/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala deleted file mode 100644 index 79d18d1d..00000000 --- a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/SlickSupport.scala +++ /dev/null @@ -1,8 +0,0 @@ -package pl.iterators.kebs.tagged.slick - -import slick.lifted.Isomorphism -import pl.iterators.kebs.tagged._ - -trait SlickSupport { - implicit def taggedColumnType[T, U]: Isomorphism[T @@ U, T] = new Isomorphism[T @@ U, T](identity, _.@@[U]) -} diff --git a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/TaggedSlickSupport.scala b/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/TaggedSlickSupport.scala new file mode 100644 index 00000000..7af03f37 --- /dev/null +++ b/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/TaggedSlickSupport.scala @@ -0,0 +1,12 @@ +package pl.iterators.kebs.tagged.slick + +import pl.iterators.kebs.tagged._ +import _root_.slick.jdbc.JdbcProfile + +trait TaggedSlickSupport { this: JdbcProfile => + trait TaggedImplicits { + implicit def taggedColumnType[T, U](implicit baseColumnType: BaseColumnType[T]): BaseColumnType[T @@ U] = { + MappedColumnType.base[T @@ U, T](identity, _.@@[U]) + } + } +} diff --git a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/package.scala b/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/package.scala deleted file mode 100644 index 4f297b17..00000000 --- a/tagged/jvm/src/main/scala/pl/iterators/kebs/tagged/slick/package.scala +++ /dev/null @@ -1,3 +0,0 @@ -package pl.iterators.kebs.tagged - -package object slick extends SlickSupport diff --git a/tagged/jvm/src/test/scala/SlickTaggedColumnTypeTests.scala b/tagged/jvm/src/test/scala/SlickTaggedColumnTypeTests.scala index 91170675..ba9242fd 100644 --- a/tagged/jvm/src/test/scala/SlickTaggedColumnTypeTests.scala +++ b/tagged/jvm/src/test/scala/SlickTaggedColumnTypeTests.scala @@ -1,18 +1,24 @@ -import slick.jdbc.PostgresProfile.api._ +import slick.jdbc.PostgresProfile import pl.iterators.kebs.tagged._ -import pl.iterators.kebs.tagged.slick.{SlickSupport} +import pl.iterators.kebs.tagged.slick.TaggedSlickSupport import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers -class SlickTaggedColumnTypeTests extends AnyFunSuite with Matchers with SlickSupport { +class SlickTaggedColumnTypeTests extends AnyFunSuite with Matchers { + + object MyPostgresProfile extends PostgresProfile with TaggedSlickSupport { + override val api: APITagged = new APITagged {} + trait APITagged extends JdbcAPI with TaggedImplicits + } + + import MyPostgresProfile.api._ + trait IdTag type Id = Long @@ IdTag trait NameTag type Name = String @@ NameTag - case class Row(id: Id, name: Name, num: Long) - test("MappedColumnType for tagged types") { "implicitly[BaseColumnType[Long @@ IdTag]]" should compile } diff --git a/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala b/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala deleted file mode 100644 index 0bf1ce38..00000000 --- a/tagged/jvm/src/test/scala/TaggedTypeIsomorphismTests.scala +++ /dev/null @@ -1,28 +0,0 @@ -import pl.iterators.kebs.tagged.slick.SlickSupport -import slick.lifted.Isomorphism -import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.matchers.should.Matchers - -class TaggedTypeIsomorphismTests extends AnyFunSuite with Matchers with SlickSupport { - import pl.iterators.kebs.tagged._ - - trait Tag1 - - type Simple = Int @@ Tag1 - object Simple { - def apply(i: Int) = i.@@[Tag1] - } - - test("implicit isomorphism between bare type and type with tag") { - val iso = implicitly[Isomorphism[Int @@ Tag1, Int]] - iso.map(Simple(10)) shouldBe 10 - iso.comap(10) shouldBe Simple(10) - } - - test("implicit isomorphism between bare type and type with tag (alias)") { - val iso = implicitly[Isomorphism[Simple, Int]] - iso.map(Simple(10)) shouldBe 10 - iso.comap(10) shouldBe Simple(10) - } - -} From 0d80e41850f8090929bc7a7ee2e11daa1b1c37f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Sowa?= Date: Mon, 15 Jul 2024 18:08:09 +0200 Subject: [PATCH 2/6] Buming CI to 3.3.3 --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index baf749fc..1f2012fa 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,7 +14,7 @@ jobs: strategy: matrix: os: [ubuntu-latest] - scala: [2.13.11, 3.3.0] + scala: [2.13.11, 3.3.3] java: [temurin@17] runs-on: ${{ matrix.os }} steps: From a0fe39840648ad71fa735506caa1ab871a50c149 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Sowa?= Date: Mon, 15 Jul 2024 18:23:31 +0200 Subject: [PATCH 3/6] given -> implicit for ValueClassReps --- .../scala-3/pl/iterators/kebs/core/macros/ValueClassReps.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/scala-3/pl/iterators/kebs/core/macros/ValueClassReps.scala b/core/src/main/scala-3/pl/iterators/kebs/core/macros/ValueClassReps.scala index 526bfd9d..51227554 100644 --- a/core/src/main/scala-3/pl/iterators/kebs/core/macros/ValueClassReps.scala +++ b/core/src/main/scala-3/pl/iterators/kebs/core/macros/ValueClassReps.scala @@ -5,7 +5,7 @@ import scala.deriving.Mirror final class ValueClassLike[VC, F1](val apply: F1 => VC, val unapply: VC => F1) trait CaseClass1ToValueClass { - inline given[T <: Product, F1](using m: Mirror.ProductOf[T], teq: m.MirroredElemTypes =:= F1 *: EmptyTuple.type): ValueClassLike[T, F1] = { + implicit def repFromCaseClass[T <: Product, F1](using m: Mirror.ProductOf[T], teq: m.MirroredElemTypes =:= F1 *: EmptyTuple.type): ValueClassLike[T, F1] = { new ValueClassLike[T, F1](f1 => m.fromProduct(Tuple1(f1)), _.productElement(0).asInstanceOf[F1]) } } From 7cdd617c1998483007debaedb1a353f8a4a8952d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Sowa?= Date: Mon, 15 Jul 2024 18:34:50 +0200 Subject: [PATCH 4/6] Removing -Xsource:3 temporarily --- build.sbt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build.sbt b/build.sbt index 4b6cb643..bca3fc3d 100644 --- a/build.sbt +++ b/build.sbt @@ -2,7 +2,7 @@ import sbt.librarymanagement.ConflictWarning val scala_2_13 = "2.13.14" val scala_3 = "3.3.3" -val mainScalaVersion = scala_3 +val mainScalaVersion = scala_2_13 val supportedScalaVersions = Seq(scala_2_13, scala_3) ThisBuild / crossScalaVersions := supportedScalaVersions @@ -15,7 +15,7 @@ lazy val baseSettings = Seq( organizationName := "Iterators", organizationHomepage := Some(url("https://iterato.rs")), homepage := Some(url("https://github.com/theiterators/kebs")), - scalacOptions ++= Seq("-deprecation", "-unchecked", "-feature", "-encoding", "utf8") ++ (if (scalaVersion.value.startsWith("3")) Seq("-Xmax-inlines", "64", "-Yretain-trees") else Seq("-Xsource:3")), + scalacOptions ++= Seq("-deprecation", "-unchecked", "-feature", "-encoding", "utf8") ++ (if (scalaVersion.value.startsWith("3")) Seq("-Xmax-inlines", "64", "-Yretain-trees") else Seq.empty), ) lazy val commonMacroSettings = baseSettings ++ Seq( From fdd686e36f9d8df56aaccf27fa5f1a051543b0cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Sowa?= Date: Mon, 15 Jul 2024 18:44:30 +0200 Subject: [PATCH 5/6] scala version oops --- build.sbt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.sbt b/build.sbt index bca3fc3d..96f5cc1e 100644 --- a/build.sbt +++ b/build.sbt @@ -2,7 +2,7 @@ import sbt.librarymanagement.ConflictWarning val scala_2_13 = "2.13.14" val scala_3 = "3.3.3" -val mainScalaVersion = scala_2_13 +val mainScalaVersion = scala_3 val supportedScalaVersions = Seq(scala_2_13, scala_3) ThisBuild / crossScalaVersions := supportedScalaVersions From 952d31a3913e2701efd7606702b9dd12e6511b1e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Sowa?= Date: Sat, 20 Jul 2024 19:59:22 +0200 Subject: [PATCH 6/6] Slick cleanup --- .../kebs/examples/EnumValueColumnType.scala | 4 +- .../kebs/examples/HStoreColumnType.scala | 4 +- .../examples/HStoreExtensionMethods.scala | 4 +- .../kebs/examples/ListValueCommonType.scala | 4 +- .../kebs/slick/BasicSlickSupport.scala | 274 ------------------ .../kebs/slick/KebsSlickSupport.scala | 219 ++++++++++++++ .../SlickMappedColumnTypeTests.scala | 6 +- .../SlickMappedColumnTypeTests.scala | 6 +- .../arrays/SlickPgArrayColumnTypeTests.scala | 6 +- .../kebs/slick/arrays/SlickPgArrayTests.scala | 6 +- .../kebs/slick/caseclasses/SlickPgTests.scala | 6 +- .../SlickMappedEnumColumnTypeTests.scala | 6 +- .../SlickMappedValueEnumColumnTypeTests.scala | 4 +- .../hstore/SlickPgHstoreColumnTypeTests.scala | 6 +- .../slick/hstore/SlickPgHstoreTests.scala | 6 +- 15 files changed, 253 insertions(+), 308 deletions(-) delete mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala create mode 100644 slick/src/main/scala/pl/iterators/kebs/slick/KebsSlickSupport.scala diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala b/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala index c8ba4021..5d61b36c 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/EnumValueColumnType.scala @@ -98,11 +98,11 @@ object EnumValueColumnType { object AfterKebsTraitStyle { - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport object MyPostgresProfile extends ExPostgresProfile { override val api: APIWithKebsAndEnums = new APIWithKebsAndEnums {} - trait APIWithKebsAndEnums extends super.API with BasicSlickSupport with KebsEnums.Lowercase + trait APIWithKebsAndEnums extends super.API with KebsSlickSupport with KebsEnums.Lowercase } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala index 2820e667..0fd39192 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreColumnType.scala @@ -73,11 +73,11 @@ object HStoreColumnType { object AfterKebs { import pl.iterators.kebs.circe.instances.time.YearMonthString - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport { override val api: APIWithHstore = new APIWithHstore {} - trait APIWithHstore extends super.API with HStoreImplicits with BasicSlickSupport with YearMonthString + trait APIWithHstore extends super.API with HStoreImplicits with KebsSlickSupport with YearMonthString } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala index 7ecb4af5..a719b833 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/HStoreExtensionMethods.scala @@ -49,11 +49,11 @@ object HStoreExtensionMethods { object AfterKebs { import pl.iterators.kebs.circe.instances.time.YearMonthString - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport with PgArraySupport { override val api: APIWithHstore = new APIWithHstore {} - trait APIWithHstore extends super.API with HStoreImplicits with ArrayImplicits with BasicSlickSupport with YearMonthString + trait APIWithHstore extends super.API with HStoreImplicits with ArrayImplicits with KebsSlickSupport with YearMonthString } import MyPostgresProfile.api._ diff --git a/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala b/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala index 0cc22fa9..fb2af4ee 100644 --- a/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala +++ b/examples/src/main/scala/pl/iterators/kebs/examples/ListValueCommonType.scala @@ -47,10 +47,10 @@ object ListValueCommonType { object AfterKebsTraitStyle { - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport object MyPostgresProfile extends ExPostgresProfile with PgArraySupport { override val api: APIWithArraysAndKebs = new APIWithArraysAndKebs {} - trait APIWithArraysAndKebs extends super.API with ArrayImplicits with BasicSlickSupport + trait APIWithArraysAndKebs extends super.API with ArrayImplicits with KebsSlickSupport } import MyPostgresProfile.api._ diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala b/slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala deleted file mode 100644 index fbc84157..00000000 --- a/slick/src/main/scala/pl/iterators/kebs/slick/BasicSlickSupport.scala +++ /dev/null @@ -1,274 +0,0 @@ -package pl.iterators.kebs.slick - -import pl.iterators.kebs.core.enums.{EnumLike, ValueEnumLike, ValueEnumLikeEntry} -import pl.iterators.kebs.core.instances.InstanceConverter -import pl.iterators.kebs.core.macros.ValueClassLike -import pl.iterators.kebs.slick.hstore.KebsHStoreColumnExtensionMethods -import slick.ast.{BaseTypedType, NumericTypedType} -import slick.jdbc.{JdbcProfile, JdbcType} -import slick.lifted._ - -import scala.language.implicitConversions -import scala.reflect.ClassTag - -trait KebsColumnExtensionMethods { - implicit def stringValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[CC] = - new StringColumnExtensionMethods[CC](rep) - implicit def stringValueOptionColumnExt[CC](rep: Rep[Option[CC]])( - implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[Option[CC]] = new StringColumnExtensionMethods[Option[CC]](rep) - implicit def numericValueColumnExt[CC, B](rep: Rep[CC])( - implicit ev1: ValueClassLike[CC, B], - ev2: BaseTypedType[B] with NumericTypedType): BaseNumericColumnExtensionMethods[CC] = new BaseNumericColumnExtensionMethods[CC](rep) - implicit def numericValueOptionColumnExt[CC, B](rep: Rep[Option[CC]])( - implicit ev1: ValueClassLike[CC, B], - ev2: BaseTypedType[B] with NumericTypedType): OptionNumericColumnExtensionMethods[CC] = - new OptionNumericColumnExtensionMethods[CC](rep) - implicit def booleanValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[CC] = - new BooleanColumnExtensionMethods[CC](rep) - implicit def booleanValueOptionColumnExt[CC](rep: Rep[Option[CC]])( - implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[Option[CC]] = - new BooleanColumnExtensionMethods[Option[CC]](rep) - - implicit def hstoreColumnExt[KEY, VALUE](c: Rep[Map[KEY, VALUE]])( - implicit tm0: JdbcType[KEY], - tm1: JdbcType[VALUE], - tm2: JdbcType[List[KEY]], - tm3: JdbcType[List[VALUE]], - tm4: JdbcType[Map[KEY, VALUE]] - ): KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]] = - new KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]](c) - - @inline implicit def getCCOptionMapper2TT_1[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, B2, BR] = - OptionMapper2.plain.asInstanceOf[OptionMapper2[B1, B2, BR, CC, B2, BR]] - @inline implicit def getCCOptionMapper2TT_2[B1, B2, BR, CC](implicit ev: ValueClassLike[CC, B2]): OptionMapper2[CC, CC, BR, CC, B2, BR] = - OptionMapper2.plain.asInstanceOf[OptionMapper2[CC, CC, BR, CC, B2, BR]] - @inline implicit def getCCOptionMapper2TO[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]] = - OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]]] - @inline implicit def getCCOptionMapper2OT[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]] = - OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]]] - @inline implicit def getCCOptionMapper2OO[B1, B2: BaseTypedType, BR, CC]( - implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]] = - OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]]] -} - -trait BasicSlickSupport { this: JdbcProfile => - trait BasicSlickImplicits extends KebsColumnExtensionMethods { - implicit final def intMapValueColumnType(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, String]] = MappedColumnType.base[Map[Int, String], Map[String, String]]( - _.map { case (int, str) => (int.toString, str) }, - _.map { case (str1, str2) => (str1.toInt, str2) } - ) - - implicit final def longMapValueColumnType(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, String]] = MappedColumnType.base[Map[Long, String], Map[String, String]]( - _.map { case (long, str) => (long.toString, str) }, - _.map { case (str1, str2) => (str1.toLong, str2) } - ) - - implicit final def boolMapValueColumnType(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, String]] = MappedColumnType.base[Map[Boolean, String], Map[String, String]]( - _.map { case (bool, str) => (bool.toString, str) }, - _.map { case (str1, str2) => (str1.toBoolean, str2) } - ) - - implicit final def intMapValueColumnType1(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Int]] = MappedColumnType.base[Map[String, Int], Map[String, String]]( - _.map { case (str, int) => (str, int.toString) }, - _.map { case (str, str1) => (str, str1.toInt) } - ) - - implicit final def longMapValueColumnType1(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Long]] = MappedColumnType.base[Map[String, Long], Map[String, String]]( - _.map { case (str, long) => (str, long.toString) }, - _.map { case (str, str1) => (str, str1.toLong) } - ) - - implicit final def boolMapValueColumnType1(implicit bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Boolean]] = MappedColumnType.base[Map[String, Boolean], Map[String, String]]( - _.map { case (str, bool) => (str, bool.toString) }, - _.map { case (str, str1) => (str, str1.toBoolean) } - ) - } - - trait ValueClassLikeImplicits { - implicit def valueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], bct: BaseColumnType[B], cls: ClassTag[CC]): BaseColumnType[CC] = - MappedColumnType.base[CC, B](rep1.unapply, rep1.apply) - - implicit def listValueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], bct: BaseColumnType[List[B]], cls: ClassTag[CC]): BaseColumnType[List[CC]] = - MappedColumnType.base[List[CC], List[B]](_.map(rep1.unapply), _.map(rep1.apply)) - - implicit def hstoreColumnType[CC1, CC2, A, B]( - implicit rep1: ValueClassLike[CC1, A], - rep2: ValueClassLike[CC2, B], - bct: BaseColumnType[Map[A, B]] - ): BaseColumnType[Map[CC1, CC2]] = - MappedColumnType.base[Map[CC1, CC2], Map[A, B]](_.map { case (cc1, cc2) => (rep1.unapply(cc1), rep2.unapply(cc2)) }, - _.map { case (a, b) => (rep1.apply(a), rep2.apply(b)) }) - - implicit def hstoreColumnType1[CC1, A, B]( - implicit rep1: ValueClassLike[CC1, A], - rep2: EnumLike[B], - bct: BaseColumnType[Map[A, String]] - ): BaseColumnType[Map[CC1, B]] = - MappedColumnType.base[Map[CC1, B], Map[A, String]](_.map { case (cc1, b) => (rep1.unapply(cc1), b.toString) }, // TODO: casing - _.map { case (a, str) => (rep1.apply(a), rep2.withName(str)) }) - - implicit def hstoreColumnType2[CC2, A, B]( - implicit rep1: EnumLike[A], - rep2: ValueClassLike[CC2, B], - bct: BaseColumnType[Map[String, B]] - ): BaseColumnType[Map[A, CC2]] = - MappedColumnType.base[Map[A, CC2], Map[String, B]](_.map { case (a, cc2) => (a.toString, rep2.unapply(cc2)) }, - _.map { case (str, cc2) => (rep1.withName(str), rep2.apply(cc2)) }) - - implicit def hstoreColumnType3[CC1, A, B]( - implicit rep1: ValueClassLike[CC1, A], - rep2: EnumLike[B], - bct: BaseColumnType[Map[A, String]] - ): BaseColumnType[Map[CC1, B]] = - MappedColumnType.base[Map[CC1, B], Map[A, String]](_.map { case (cc1, b) => (rep1.unapply(cc1), b.toString) }, // TODO: casing - _.map { case (a, str) => (rep1.apply(a), rep2.withName(str)) }) - } - - trait InstanceConverterImplicits { - implicit def valueTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[B], cls: ClassTag[CC]): BaseColumnType[CC] = - MappedColumnType.base[CC, B](ico.encode, ico.decode) - - implicit def listTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[List[B]], cls: ClassTag[CC]): BaseColumnType[List[CC]] = - MappedColumnType.base[List[CC], List[B]](_.map(ico.encode), _.map(ico.decode)) - - implicit def seqTransitionColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[Seq[B]], cls: ClassTag[CC]): BaseColumnType[Seq[CC]] = { - MappedColumnType.base[Seq[CC], Seq[B]](_.map(ico.encode), _.map(ico.decode)) - } - - def instancesIsoMapVal[Obj, Value, MapVal](comap1: String => Value, comap2: String => MapVal)( - implicit ico: InstanceConverter[Obj, Value], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, MapVal]] = - MappedColumnType.base[Map[Obj, MapVal], Map[String, String]]( - _.map { case (obj, mapval) => (ico.encode(obj).toString, mapval.toString) }, - _.map { case (str1, str2) => (ico.decode(comap1(str1)), comap2(str2)) } - ) - - def instancesIsoMapKey[Obj, Value, MapKey](comap1: String => Value, comap2: String => MapKey)( - implicit ico: InstanceConverter[Obj, Value], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[MapKey, Obj]] = - MappedColumnType.base[Map[MapKey, Obj], Map[String, String]]( - _.map { case (mapkey, obj) => (mapkey.toString, ico.encode(obj).toString) }, - _.map { case (str1, str2) => (comap2(str1), ico.decode(comap1(str2))) } - ) - - implicit def instancesIsoObj2Str[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, String]] = - instancesIsoMapVal[Obj, String, String](identity[String], identity[String]) - - implicit def instancesIsoObj2Str1[Obj]( - implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Obj]] = - instancesIsoMapKey[Obj, String, String](identity[String], identity[String]) - - implicit def instancesIsoObj2Str2[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Int]] = - instancesIsoMapVal[Obj, String, Int](identity[String], _.toInt) - - implicit def instancesIsoObj2Str3[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, Obj]] = - instancesIsoMapKey[Obj, String, Int](identity[String], _.toInt) - - implicit def instancesIsoObj2Str4[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Long]] = - instancesIsoMapVal[Obj, String, Long](identity[String], _.toLong) - - implicit def instancesIsoObj2Str5[Obj](implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, Obj]] = - instancesIsoMapKey[Obj, String, Long](identity[String], _.toLong) - - implicit def instancesIsoObj2Str6[Obj]( - implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Boolean]] = - instancesIsoMapVal[Obj, String, Boolean](identity[String], _.toBoolean) - - implicit def instancesIsoObj2Str7[Obj]( - implicit ico: InstanceConverter[Obj, String], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, Obj]] = - instancesIsoMapKey[Obj, String, Boolean](identity[String], _.toBoolean) - - implicit def instancesIsoObj2Int[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, String]] = - instancesIsoMapVal[Obj, Int, String](_.toInt, identity[String]) - - implicit def instancesIsoObj2Int1[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Obj]] = - instancesIsoMapKey[Obj, Int, String](_.toInt, identity[String]) - - implicit def instancesIsoObj2Int2[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Int]] = - instancesIsoMapVal[Obj, Int, Int](_.toInt, _.toInt) - - implicit def instancesIsoObj2Int3[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, Obj]] = - instancesIsoMapKey[Obj, Int, Int](_.toInt, _.toInt) - - implicit def instancesIsoObj2Int4[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Long]] = - instancesIsoMapVal[Obj, Int, Long](_.toInt, _.toLong) - - implicit def instancesIsoObj2Int5[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, Obj]] = - instancesIsoMapKey[Obj, Int, Long](_.toInt, _.toLong) - - implicit def instancesIsoObj2Int6[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Boolean]] = - instancesIsoMapVal[Obj, Int, Boolean](_.toInt, _.toBoolean) - - implicit def instancesIsoObj2Int7[Obj](implicit ico: InstanceConverter[Obj, Int], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, Obj]] = - instancesIsoMapKey[Obj, Int, Boolean](_.toInt, _.toBoolean) - - implicit def instancesIsoObj2Long[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, String]] = - instancesIsoMapVal[Obj, Long, String](_.toLong, identity[String]) - - implicit def instancesIsoObj2Long1[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[String, Obj]] = - instancesIsoMapKey[Obj, Long, String](_.toLong, identity[String]) - - implicit def instancesIsoObj2Long2[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Int]] = - instancesIsoMapVal[Obj, Long, Int](_.toLong, _.toInt) - - implicit def instancesIsoObj2Long3[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Int, Obj]] = - instancesIsoMapKey[Obj, Long, Int](_.toLong, _.toInt) - - implicit def instancesIsoObj2Long4[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Long]] = - instancesIsoMapVal[Obj, Long, Long](_.toLong, _.toLong) - - implicit def instancesIsoObj2Long5[Obj](implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Long, Obj]] = - instancesIsoMapKey[Obj, Long, Long](_.toLong, _.toLong) - - implicit def instancesIsoObj2Long6[Obj]( - implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Obj, Boolean]] = - instancesIsoMapVal[Obj, Long, Boolean](_.toLong, _.toBoolean) - - implicit def instancesIsoObj2Long7[Obj]( - implicit ico: InstanceConverter[Obj, Long], bct: BaseColumnType[Map[String, String]]): BaseColumnType[Map[Boolean, Obj]] = - instancesIsoMapKey[Obj, Long, Boolean](_.toLong, _.toBoolean) - } - - protected trait SlickEnum { - def enumIsomorphism[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = MappedColumnType.base[E, String](_.toString, `enum`.withName) - - def uppercaseEnumIsomorphism[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = - MappedColumnType.base[E, String](_.toString.toUpperCase, `enum`.withNameUppercaseOnly) - - def lowercaseEnumIsomorphism[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = - MappedColumnType.base[E, String](_.toString.toLowerCase, `enum`.withNameLowercaseOnly) - } - - protected trait SlickValueEnum { - def valueEnumIsomorphism[V, E <: ValueEnumLikeEntry[V]](`enum`: ValueEnumLike[V, E])(implicit bct: BaseColumnType[V], cls: ClassTag[E]): BaseColumnType[E] = - MappedColumnType.base[E, V](_.value, `enum`.withValue) - } - - trait EnumImplicits extends SlickValueEnum with SlickEnum { - implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = enumIsomorphism(ev) - - implicit def valueEnumColumn[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E], bct: BaseColumnType[V], cls: ClassTag[E]): BaseColumnType[E] = - valueEnumIsomorphism(ev) - - implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { - MappedColumnType.base[List[E], List[String]](_.map(_.toString), _.map(ev.withName)) - } - } - - trait LowercaseEnumImplicits extends SlickValueEnum with SlickEnum { - implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = lowercaseEnumIsomorphism(ev) - - implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { - MappedColumnType.base[List[E], List[String]](_.map(_.toString.toLowerCase), _.map(ev.withNameLowercaseOnly)) - } - } - - trait UppercaseEnumImplicits extends SlickValueEnum with SlickEnum { - implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = uppercaseEnumIsomorphism(ev) - - implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { - MappedColumnType.base[List[E], List[String]](_.map(_.toString.toUpperCase), _.map(ev.withNameUppercaseOnly)) - } - } -} diff --git a/slick/src/main/scala/pl/iterators/kebs/slick/KebsSlickSupport.scala b/slick/src/main/scala/pl/iterators/kebs/slick/KebsSlickSupport.scala new file mode 100644 index 00000000..b0490539 --- /dev/null +++ b/slick/src/main/scala/pl/iterators/kebs/slick/KebsSlickSupport.scala @@ -0,0 +1,219 @@ +package pl.iterators.kebs.slick + +import pl.iterators.kebs.core.enums.{EnumLike, ValueEnumLike, ValueEnumLikeEntry} +import pl.iterators.kebs.core.instances.InstanceConverter +import pl.iterators.kebs.core.macros.ValueClassLike +import pl.iterators.kebs.slick.hstore.KebsHStoreColumnExtensionMethods +import slick.ast.{BaseTypedType, NumericTypedType} +import slick.jdbc.{JdbcProfile, JdbcType} +import slick.lifted._ + +import scala.language.implicitConversions +import scala.reflect.ClassTag + +trait KebsColumnExtensionMethods { + implicit def stringValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[CC] = + new StringColumnExtensionMethods[CC](rep) + implicit def stringValueOptionColumnExt[CC](rep: Rep[Option[CC]])( + implicit ev: ValueClassLike[CC, String]): StringColumnExtensionMethods[Option[CC]] = new StringColumnExtensionMethods[Option[CC]](rep) + implicit def numericValueColumnExt[CC, B](rep: Rep[CC])( + implicit ev1: ValueClassLike[CC, B], + ev2: BaseTypedType[B] with NumericTypedType): BaseNumericColumnExtensionMethods[CC] = new BaseNumericColumnExtensionMethods[CC](rep) + implicit def numericValueOptionColumnExt[CC, B](rep: Rep[Option[CC]])( + implicit ev1: ValueClassLike[CC, B], + ev2: BaseTypedType[B] with NumericTypedType): OptionNumericColumnExtensionMethods[CC] = + new OptionNumericColumnExtensionMethods[CC](rep) + implicit def booleanValueColumnExt[CC](rep: Rep[CC])(implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[CC] = + new BooleanColumnExtensionMethods[CC](rep) + implicit def booleanValueOptionColumnExt[CC](rep: Rep[Option[CC]])( + implicit ev: ValueClassLike[CC, Boolean]): BooleanColumnExtensionMethods[Option[CC]] = + new BooleanColumnExtensionMethods[Option[CC]](rep) + + implicit def hstoreColumnExt[KEY, VALUE](c: Rep[Map[KEY, VALUE]])( + implicit tm0: JdbcType[KEY], + tm1: JdbcType[VALUE], + tm2: JdbcType[List[KEY]], + tm3: JdbcType[List[VALUE]], + tm4: JdbcType[Map[KEY, VALUE]] + ): KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]] = + new KebsHStoreColumnExtensionMethods[KEY, VALUE, Map[KEY, VALUE]](c) + + @inline implicit def getCCOptionMapper2TT_1[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, B2, BR] = + OptionMapper2.plain.asInstanceOf[OptionMapper2[B1, B2, BR, CC, B2, BR]] + @inline implicit def getCCOptionMapper2TT_2[B1, B2, BR, CC](implicit ev: ValueClassLike[CC, B2]): OptionMapper2[CC, CC, BR, CC, B2, BR] = + OptionMapper2.plain.asInstanceOf[OptionMapper2[CC, CC, BR, CC, B2, BR]] + @inline implicit def getCCOptionMapper2TO[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]] = + OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, CC, Option[B2], Option[BR]]] + @inline implicit def getCCOptionMapper2OT[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]] = + OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], B2, Option[BR]]] + @inline implicit def getCCOptionMapper2OO[B1, B2: BaseTypedType, BR, CC]( + implicit ev: ValueClassLike[CC, B1]): OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]] = + OptionMapper2.option.asInstanceOf[OptionMapper2[B1, B2, BR, Option[CC], Option[B2], Option[BR]]] +} + +trait KebsSlickSupport { this: JdbcProfile => + trait ToFromStringForHstore[T] { + def to(value: T): String + def from(value: String): T + } + + trait KebsBasicImplicits extends KebsColumnExtensionMethods { + implicit def hstoreColumnType[A, B]( + implicit k: ToFromStringForHstore[A], + v: ToFromStringForHstore[B], + bct: BaseColumnType[Map[String, String]] + ): BaseColumnType[Map[A, B]] = + MappedColumnType.base[Map[A, B], Map[String, String]]( + _.map { case (a, b) => (k.to(a), v.to(b)) }, + _.map { case (a, b) => (k.from(a), v.from(b)) } + ) + + implicit val intToFromStringForHstore: ToFromStringForHstore[Int] = new ToFromStringForHstore[Int] { + override def to(value: Int): String = value.toString + override def from(value: String): Int = value.toInt + } + + implicit val longToFromStringForHstore: ToFromStringForHstore[Long] = new ToFromStringForHstore[Long] { + override def to(value: Long): String = value.toString + override def from(value: String): Long = value.toLong + } + + implicit val booleanToFromStringForHstore: ToFromStringForHstore[Boolean] = new ToFromStringForHstore[Boolean] { + override def to(value: Boolean): String = value.toString + override def from(value: String): Boolean = value.toBoolean + } + + implicit val stringToFromStringForHstore: ToFromStringForHstore[String] = new ToFromStringForHstore[String] { + override def to(value: String): String = value + override def from(value: String): String = value + } + + implicit val doubleToFromStringForHstore: ToFromStringForHstore[Double] = new ToFromStringForHstore[Double] { + override def to(value: Double): String = value.toString + override def from(value: String): Double = value.toDouble + } + + implicit val floatToFromStringForHstore: ToFromStringForHstore[Float] = new ToFromStringForHstore[Float] { + override def to(value: Float): String = value.toString + override def from(value: String): Float = value.toFloat + } + + implicit val shortToFromStringForHstore: ToFromStringForHstore[Short] = new ToFromStringForHstore[Short] { + override def to(value: Short): String = value.toString + override def from(value: String): Short = value.toShort + } + + implicit val byteToFromStringForHstore: ToFromStringForHstore[Byte] = new ToFromStringForHstore[Byte] { + override def to(value: Byte): String = value.toString + override def from(value: String): Byte = value.toByte + } + + implicit val charToFromStringForHstore: ToFromStringForHstore[Char] = new ToFromStringForHstore[Char] { + override def to(value: Char): String = value.toString + override def from(value: String): Char = value.head + } + + implicit val bigDecimalToFromStringForHstore: ToFromStringForHstore[BigDecimal] = new ToFromStringForHstore[BigDecimal] { + override def to(value: BigDecimal): String = value.toString + override def from(value: String): BigDecimal = BigDecimal(value) + } + + implicit val bigIntToFromStringForHstore: ToFromStringForHstore[BigInt] = new ToFromStringForHstore[BigInt] { + override def to(value: BigInt): String = value.toString + override def from(value: String): BigInt = BigInt(value) + } + } + + trait KebsValueClassLikeImplicits { + implicit def valueClassLikeColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], bct: BaseColumnType[B], cls: ClassTag[CC]): BaseColumnType[CC] = + MappedColumnType.base[CC, B](rep1.unapply, rep1.apply) + + implicit def listValueColumnType[CC, B](implicit rep1: ValueClassLike[CC, B], bct: BaseColumnType[List[B]], cls: ClassTag[CC]): BaseColumnType[List[CC]] = + MappedColumnType.base[List[CC], List[B]](_.map(rep1.unapply), _.map(rep1.apply)) + + implicit def valueClassLikeToFromStringForHstore[CC, B](implicit rep: ValueClassLike[CC, B], toFromStringForHstore: ToFromStringForHstore[B]): ToFromStringForHstore[CC] = + new ToFromStringForHstore[CC] { + override def to(value: CC): String = toFromStringForHstore.to(rep.unapply(value)) + override def from(value: String): CC = rep.apply(toFromStringForHstore.from(value)) + } + } + + trait KebsInstanceConverterImplicits { + implicit def instanceConverterColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[B], cls: ClassTag[CC]): BaseColumnType[CC] = + MappedColumnType.base[CC, B](ico.encode, ico.decode) + + implicit def listInstanceConverterColumnType[CC, B](implicit ico: InstanceConverter[CC, B], bct: BaseColumnType[List[B]], cls: ClassTag[CC]): BaseColumnType[List[CC]] = + MappedColumnType.base[List[CC], List[B]](_.map(ico.encode), _.map(ico.decode)) + + implicit def instanceConverterToFromStringForHstore[CC, B](implicit ico: InstanceConverter[CC, B], toFromStringForHstore: ToFromStringForHstore[B]): ToFromStringForHstore[CC] = + new ToFromStringForHstore[CC] { + override def to(value: CC): String = toFromStringForHstore.to(ico.encode(value)) + override def from(value: String): CC = ico.decode(toFromStringForHstore.from(value)) + } + } + + protected trait SlickEnum { + def enumColumn[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = MappedColumnType.base[E, String](_.toString, `enum`.withName) + + def uppercaseEnumColumn[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = + MappedColumnType.base[E, String](_.toString.toUpperCase, `enum`.withNameUppercaseOnly) + + def lowercaseEnumColumn[E](`enum`: EnumLike[E])(implicit bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = + MappedColumnType.base[E, String](_.toString.toLowerCase, `enum`.withNameLowercaseOnly) + } + + protected trait SlickValueEnum { + def valueEnumColumnType[V, E <: ValueEnumLikeEntry[V]](`enum`: ValueEnumLike[V, E])(implicit bct: BaseColumnType[V], cls: ClassTag[E]): BaseColumnType[E] = + MappedColumnType.base[E, V](_.value, `enum`.withValue) + } + + trait EnumImplicits extends SlickValueEnum with SlickEnum { + implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = enumColumn(ev) + + implicit def valueEnumColumn[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E], bct: BaseColumnType[V], cls: ClassTag[E]): BaseColumnType[E] = + valueEnumColumnType(ev) + + implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { + MappedColumnType.base[List[E], List[String]](_.map(_.toString), _.map(ev.withName)) + } + + implicit def enumToFromStringForHstore[E](implicit ev: EnumLike[E]): ToFromStringForHstore[E] = new ToFromStringForHstore[E] { + override def to(value: E): String = value.toString + override def from(value: String): E = ev.withName(value) + } + + implicit def valueEnumToFromStringForHstore[V, E <: ValueEnumLikeEntry[V]](implicit ev: ValueEnumLike[V, E], tfs: ToFromStringForHstore[V]): ToFromStringForHstore[E] = new ToFromStringForHstore[E] { + override def to(value: E): String = tfs.to(value.value) + override def from(value: String): E = ev.withValue(tfs.from(value)) + } + } + + trait LowercaseEnumImplicits extends SlickValueEnum with SlickEnum { + implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = lowercaseEnumColumn(ev) + + implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { + MappedColumnType.base[List[E], List[String]](_.map(_.toString.toLowerCase), _.map(ev.withNameLowercaseOnly)) + } + + implicit def toFromStringForHstoreEnum[E](implicit ev: EnumLike[E]): ToFromStringForHstore[E] = new ToFromStringForHstore[E] { + override def to(value: E): String = value.toString.toLowerCase + override def from(value: String): E = ev.withNameLowercaseOnly(value) + } + } + + trait UppercaseEnumImplicits extends SlickValueEnum with SlickEnum { + implicit def enumValueColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[String], cls: ClassTag[E]): BaseColumnType[E] = uppercaseEnumColumn(ev) + + implicit def enumListColumn[E](implicit ev: EnumLike[E], bct: BaseColumnType[List[String]]): BaseColumnType[List[E]] = { + MappedColumnType.base[List[E], List[String]](_.map(_.toString.toUpperCase), _.map(ev.withNameUppercaseOnly)) + } + + implicit def toFromStringForHstoreEnum[E](implicit ev: EnumLike[E]): ToFromStringForHstore[E] = new ToFromStringForHstore[E] { + override def to(value: E): String = value.toString.toUpperCase + override def from(value: String): E = ev.withNameUppercaseOnly(value) + } + } +} diff --git a/slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala b/slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala index 1f9b00e4..6d80a72d 100644 --- a/slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala +++ b/slick/src/test/scala-2/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala @@ -3,13 +3,13 @@ package pl.iterators.kebs.slick.caseclasses import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import pl.iterators.kebs.core.macros.CaseClass1ToValueClass -import pl.iterators.kebs.slick.BasicSlickSupport +import pl.iterators.kebs.slick.KebsSlickSupport import slick.jdbc.PostgresProfile class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers { - object MyPostgresProfile extends PostgresProfile with BasicSlickSupport { + object MyPostgresProfile extends PostgresProfile with KebsSlickSupport { override val api: APITagged = new APITagged {} - trait APITagged extends JdbcAPI with BasicSlickImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass + trait APITagged extends JdbcAPI with KebsBasicImplicits with KebsValueClassLikeImplicits with CaseClass1ToValueClass } import MyPostgresProfile.api._ diff --git a/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala b/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala index cbdbb301..e9a94484 100644 --- a/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala +++ b/slick/src/test/scala-3/pl/iterators/kebs/slick/caseclasses/SlickMappedColumnTypeTests.scala @@ -3,13 +3,13 @@ package pl.iterators.kebs.slick.caseclasses import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import pl.iterators.kebs.core.macros.CaseClass1ToValueClass -import pl.iterators.kebs.slick.BasicSlickSupport +import pl.iterators.kebs.slick.KebsSlickSupport import slick.jdbc.PostgresProfile class SlickMappedColumnTypeTests extends AnyFunSuite with Matchers { - object MyPostgresProfile extends PostgresProfile with BasicSlickSupport { + object MyPostgresProfile extends PostgresProfile with KebsSlickSupport { override val api: APITagged = new APITagged {} - trait APITagged extends JdbcAPI with BasicSlickImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass + trait APITagged extends JdbcAPI with KebsBasicImplicits with KebsValueClassLikeImplicits with CaseClass1ToValueClass } import MyPostgresProfile.api._ diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala index 8b008aa4..8fc22f1d 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayColumnTypeTests.scala @@ -11,11 +11,11 @@ class SlickPgArrayColumnTypeTests extends AnyFunSuite with Matchers with KebsEnu case class Institution(value: Long) case class MarketFinancialProduct(value: String) - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport - object MyPostgresProfile extends ExPostgresProfile with PgArraySupport with BasicSlickSupport { + object MyPostgresProfile extends ExPostgresProfile with PgArraySupport with KebsSlickSupport { override val api: APIWithArrays = new APIWithArrays {} - trait APIWithArrays extends ExtPostgresAPI with ArrayImplicits with BasicSlickImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass with EnumImplicits + trait APIWithArrays extends ExtPostgresAPI with ArrayImplicits with KebsBasicImplicits with KebsValueClassLikeImplicits with CaseClass1ToValueClass with EnumImplicits } import MyPostgresProfile.api._ diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala index 1cd5a193..579cb8d0 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/arrays/SlickPgArrayTests.scala @@ -11,11 +11,11 @@ import java.util.UUID class SlickPgArrayTests extends AnyFunSuite with Matchers { import pl.iterators.kebs.instances.time.YearMonthString - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport - trait PostgresDriver extends ExPostgresProfile with PgArraySupport with BasicSlickSupport { + trait PostgresDriver extends ExPostgresProfile with PgArraySupport with KebsSlickSupport { override val api: ArrayAPI = new ArrayAPI {} - trait ArrayAPI extends ExtPostgresAPI with ArrayImplicits with ValueClassLikeImplicits with CaseClass1ToValueClass with InstanceConverterImplicits with YearMonthString + trait ArrayAPI extends ExtPostgresAPI with ArrayImplicits with KebsValueClassLikeImplicits with CaseClass1ToValueClass with KebsInstanceConverterImplicits with YearMonthString } object PostgresDriver extends PostgresDriver diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala index 53d942a9..b5183db1 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/caseclasses/SlickPgTests.scala @@ -9,16 +9,16 @@ import java.util.UUID class SlickPgTests extends AnyFunSuite with Matchers { - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport import slick.lifted.ProvenShape case class ServiceLineName(name: String) case class Id(id: Int) case class ServiceLine(id: Id, name: ServiceLineName) - trait PostgresDriver extends ExPostgresProfile with BasicSlickSupport { + trait PostgresDriver extends ExPostgresProfile with KebsSlickSupport { override val api: PostgresApi.type = PostgresApi - object PostgresApi extends ExtPostgresAPI with ValueClassLikeImplicits with CaseClass1ToValueClass with BasicSlickImplicits + object PostgresApi extends ExtPostgresAPI with KebsValueClassLikeImplicits with CaseClass1ToValueClass with KebsBasicImplicits } object PostgresDriver extends PostgresDriver diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala index 0957e208..5d887c79 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedEnumColumnTypeTests.scala @@ -8,11 +8,11 @@ import org.scalatest.matchers.should.Matchers import pl.iterators.kebs.enumeratum.KebsEnumeratum class SlickMappedEnumColumnTypeTests extends AnyFunSuite with Matchers with KebsEnumeratum { - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport - trait PostgresDriver extends ExPostgresProfile with BasicSlickSupport { + trait PostgresDriver extends ExPostgresProfile with KebsSlickSupport { override val api: EnumAPI = new EnumAPI {} - trait EnumAPI extends ExtPostgresAPI with BasicSlickImplicits with ValueClassLikeImplicits with EnumImplicits + trait EnumAPI extends ExtPostgresAPI with KebsBasicImplicits with KebsValueClassLikeImplicits with EnumImplicits } object PostgresDriver extends PostgresDriver diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala index a0f75eaa..df16ea38 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/enums/SlickMappedValueEnumColumnTypeTests.scala @@ -5,11 +5,11 @@ import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import pl.iterators.kebs.core.enums.ValueEnumLikeEntry import pl.iterators.kebs.enumeratum.KebsValueEnumeratum -import pl.iterators.kebs.slick.BasicSlickSupport +import pl.iterators.kebs.slick.KebsSlickSupport import slick.jdbc.PostgresProfile class SlickMappedValueEnumColumnTypeTests extends AnyFunSuite with Matchers with KebsValueEnumeratum { - object MyPostgresProfile extends PostgresProfile with BasicSlickSupport { + object MyPostgresProfile extends PostgresProfile with KebsSlickSupport { override val api: APITagged = new APITagged {} trait APITagged extends JdbcAPI with EnumImplicits } diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala index 0d86b712..c191054f 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreColumnTypeTests.scala @@ -8,12 +8,12 @@ import pl.iterators.kebs.core.macros.CaseClass1ToValueClass class SlickPgHstoreColumnTypeTests extends AnyFunSuite with Matchers { import pl.iterators.kebs.instances.time.{DayOfWeekInt, YearMonthString} import pl.iterators.kebs.instances.time.mixins.InstantEpochMilliLong - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport import java.time.{DayOfWeek, YearMonth, Instant} - object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport with BasicSlickSupport { + object MyPostgresProfile extends ExPostgresProfile with PgHStoreSupport with KebsSlickSupport { override val api: APIWithHStore = new APIWithHStore {} - trait APIWithHStore extends ExtPostgresAPI with HStoreImplicits with BasicSlickImplicits with InstanceConverterImplicits with YearMonthString with DayOfWeekInt with InstantEpochMilliLong with ValueClassLikeImplicits with CaseClass1ToValueClass + trait APIWithHStore extends ExtPostgresAPI with HStoreImplicits with KebsBasicImplicits with KebsInstanceConverterImplicits with YearMonthString with DayOfWeekInt with InstantEpochMilliLong with KebsValueClassLikeImplicits with CaseClass1ToValueClass } case class CategoryName(name: String) diff --git a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala index d189b5c3..c6dffdff 100644 --- a/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala +++ b/slick/src/test/scala/pl/iterators/kebs/slick/hstore/SlickPgHstoreTests.scala @@ -11,11 +11,11 @@ import java.util.UUID class SlickPgHstoreTests extends AnyFunSuite with Matchers { import pl.iterators.kebs.instances.time.YearMonthString - import pl.iterators.kebs.slick.BasicSlickSupport + import pl.iterators.kebs.slick.KebsSlickSupport - trait PostgresDriver extends ExPostgresProfile with PgArraySupport with PgHStoreSupport with BasicSlickSupport { + trait PostgresDriver extends ExPostgresProfile with PgArraySupport with PgHStoreSupport with KebsSlickSupport { override val api: HstoreAPI = new HstoreAPI {} - trait HstoreAPI extends ExtPostgresAPI with ArrayImplicits with HStoreImplicits with BasicSlickImplicits with YearMonthString with ValueClassLikeImplicits with CaseClass1ToValueClass with InstanceConverterImplicits + trait HstoreAPI extends ExtPostgresAPI with ArrayImplicits with HStoreImplicits with KebsBasicImplicits with YearMonthString with KebsValueClassLikeImplicits with CaseClass1ToValueClass with KebsInstanceConverterImplicits } object PostgresDriver extends PostgresDriver