Add SimpleTable construct based on Named Tuples

.mill-version

@@ -1 +1 @@
-0.12.0
+0.12.10

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.8.1"
+version = "3.9.5"
 
 align.preset = none
 align.openParenCallSite = false

build.mill

@@ -8,10 +8,11 @@ import de.tobiasroeser.mill.vcs.version.VcsVersion
 import com.goyeau.mill.scalafix.ScalafixModule
 import mill._, scalalib._, publish._
 
-val scalaVersions = Seq("2.13.12", "3.6.2")
+val scala3 = "3.6.2"
+val scalaVersions = Seq("2.13.12", scala3)
+val scala3NamedTuples = "3.7.0"
 
-trait Common extends CrossScalaModule with PublishModule with ScalafixModule{
-  def scalaVersion = crossScalaVersion
+trait CommonBase extends ScalaModule with PublishModule with ScalafixModule { common =>
 
   def publishVersion = VcsVersion.vcsState().format()
 
@@ -33,18 +34,13 @@ trait Common extends CrossScalaModule with PublishModule with ScalafixModule{
     Seq("-Wunused:privates,locals,explicits,implicits,params") ++
       Option.when(scalaVersion().startsWith("2."))("-Xsource:3")
   }
-}
-
-
-object scalasql extends Cross[ScalaSql](scalaVersions)
-trait ScalaSql extends Common{ common =>
-  def moduleDeps = Seq(query, operations)
-  def ivyDeps = Agg.empty[Dep] ++ Option.when(scalaVersion().startsWith("2."))(
-    ivy"org.scala-lang:scala-reflect:${scalaVersion()}"
-  )
 
+  def semanticDbVersion: T[String] =
+    // last version that works with Scala 2.13.12
+    "4.12.3"
 
-  object test extends ScalaTests with ScalafixModule{
+  trait CommonTest extends ScalaTests with ScalafixModule {
+    def semanticDbVersion: T[String] = common.semanticDbVersion
     def scalacOptions = common.scalacOptions
     def ivyDeps = Agg(
       ivy"com.github.vertical-blank:sql-formatter:2.0.4",
@@ -61,10 +57,51 @@ trait ScalaSql extends Common{ common =>
       ivy"com.zaxxer:HikariCP:5.1.0"
     )
 
+    def recordedTestsFile: String
+    def recordedSuiteDescriptionsFile: String
+
     def testFramework = "scalasql.UtestFramework"
 
     def forkArgs = Seq("-Duser.timezone=Asia/Singapore")
-    def forkEnv = Map("MILL_WORKSPACE_ROOT" -> T.workspace.toString())
+
+    def forkEnv = Map(
+      "MILL_WORKSPACE_ROOT" -> T.workspace.toString(),
+      "SCALASQL_RECORDED_TESTS_NAME" -> recordedTestsFile,
+      "SCALASQL_RECORDED_SUITE_DESCRIPTIONS_NAME" -> recordedSuiteDescriptionsFile
+    )
+  }
+}
+trait Common extends CommonBase with CrossScalaModule
+
+object `scalasql-namedtuples` extends CommonBase {
+  def scalaVersion: T[String] = scala3NamedTuples
+  def millSourcePath: os.Path = scalasql(scala3).millSourcePath / "namedtuples"
+  def moduleDeps: Seq[PublishModule] = Seq(scalasql(scala3))
+
+  // override def scalacOptions: Target[Seq[String]] = T {
+  //   super.scalacOptions() :+ "-Xprint:inlining"
+  // }
+
+  object test extends CommonTest {
+    def resources = scalasql(scala3).test.resources
+    def moduleDeps = super.moduleDeps ++ Seq(scalasql(scala3), scalasql(scala3).test)
+    def recordedTestsFile: String = "recordedTestsNT.json"
+    def recordedSuiteDescriptionsFile: String = "recordedSuiteDescriptionsNT.json"
+  }
+}
+
+object scalasql extends Cross[ScalaSql](scalaVersions)
+trait ScalaSql extends Common { common =>
+  def moduleDeps = Seq(query, operations)
+  def ivyDeps = Agg.empty[Dep] ++ Option.when(scalaVersion().startsWith("2."))(
+    ivy"org.scala-lang:scala-reflect:${scalaVersion()}"
+  )
+
+  override def consoleScalacOptions: T[Seq[String]] = Seq("-Xprint:typer")
+
+  object test extends CommonTest {
+    def recordedTestsFile: String = "recordedTests.json"
+    def recordedSuiteDescriptionsFile: String = "recordedSuiteDescriptions.json"
   }
 
   private def indent(code: Iterable[String]): String =
@@ -74,15 +111,14 @@ trait ScalaSql extends Common{ common =>
     def ivyDeps = Agg(
       ivy"com.lihaoyi::geny:1.0.0",
       ivy"com.lihaoyi::sourcecode:0.3.1",
-      ivy"com.lihaoyi::pprint:0.8.1",
+      ivy"com.lihaoyi::pprint:0.8.1"
     ) ++ Option.when(scalaVersion().startsWith("2."))(
       ivy"org.scala-lang:scala-reflect:${scalaVersion()}"
     )
 
     def generatedSources = T {
       def commaSep0(i: Int, f: Int => String) = Range.inclusive(1, i).map(f).mkString(", ")
 
-
       val queryableRowDefs = for (i <- Range.inclusive(2, 22)) yield {
         def commaSep(f: Int => String) = commaSep0(i, f)
         s"""implicit def Tuple${i}Queryable[${commaSep(j => s"Q$j")}, ${commaSep(j => s"R$j")}](
@@ -98,7 +134,6 @@ trait ScalaSql extends Common{ common =>
            |}""".stripMargin
       }
 
-
       os.write(
         T.dest / "Generated.scala",
         s"""package scalasql.core.generated
@@ -113,15 +148,13 @@ trait ScalaSql extends Common{ common =>
 
   }
 
-
-  object operations extends Common with CrossValue{
+  object operations extends Common with CrossValue {
     def moduleDeps = Seq(core)
   }
 
-  object query extends Common with CrossValue{
+  object query extends Common with CrossValue {
     def moduleDeps = Seq(core)
 
-
     def generatedSources = T {
       def commaSep0(i: Int, f: Int => String) = Range.inclusive(1, i).map(f).mkString(", ")
 
@@ -139,7 +172,9 @@ trait ScalaSql extends Common{ common =>
                  |      )
                  |
                  |""".stripMargin
-          s"""def batched[${commaSep(j => s"T$j")}](${commaSep(j => s"f$j: V[Column] => Column[T$j]")})(
+          s"""def batched[${commaSep(j => s"T$j")}](${commaSep(j =>
+              s"f$j: V[Column] => Column[T$j]"
+            )})(
              |    items: (${commaSep(j => s"Expr[T$j]")})*
              |)(implicit qr: Queryable[V[Column], R]): scalasql.query.InsertColumns[V, R] $impl""".stripMargin
         }
@@ -165,12 +200,15 @@ trait ScalaSql extends Common{ common =>
 
         val commaSepQ = commaSep(j => s"Q$j")
         val commaSepR = commaSep(j => s"R$j")
-        val joinAppendType = s"scalasql.query.JoinAppend[($commaSepQ), QA, ($commaSepQ, QA), ($commaSepR, RA)]"
+        val joinAppendType =
+          s"scalasql.query.JoinAppend[($commaSepQ), QA, ($commaSepQ, QA), ($commaSepR, RA)]"
         s"""
            |implicit def append$i[$commaSepQ, QA, $commaSepR, RA](
            |      implicit qr0: Queryable.Row[($commaSepQ, QA), ($commaSepR, RA)],
            |      @annotation.nowarn("msg=never used") qr20: Queryable.Row[QA, RA]): $joinAppendType = new $joinAppendType {
-           |    override def appendTuple(t: ($commaSepQ), v: QA): ($commaSepQ, QA) = (${commaSep(j => s"t._$j")}, v)
+           |    override def appendTuple(t: ($commaSepQ), v: QA): ($commaSepQ, QA) = (${commaSep(j =>
+            s"t._$j"
+          )}, v)
            |
            |    def qr: Queryable.Row[($commaSepQ, QA), ($commaSepR, RA)] = qr0
            |}""".stripMargin

docs/generateDocs.mill

@@ -5,6 +5,7 @@ def generateTutorial(sourcePath: os.Path, destPath: os.Path) =  {
   var isDocs = Option.empty[Int]
   var isCode = false
   val outputLines = collection.mutable.Buffer.empty[String]
+  val snippets = collection.mutable.HashMap.empty[String, scala.collection.BufferedIterator[String]]
   outputLines.append(generatedCodeHeader)
   for (line <- os.read.lines(sourcePath)) {
     val isDocsIndex = line.indexOf("// +DOCS")
@@ -25,6 +26,24 @@ def generateTutorial(sourcePath: os.Path, destPath: os.Path) =  {
       (suffix, isCode) match{
         case ("", _) => outputLines.append("")
 
+        case (s"// +INCLUDE SNIPPET [$key] $rest", _) =>
+          // reuse the iterator each time,
+          // basically assume snippets are requested in order.
+          val sublines: scala.collection.BufferedIterator[String] = snippets.getOrElseUpdate(rest, os.read.lines(mill.api.WorkspaceRoot.workspaceRoot / os.SubPath(rest)).iterator.buffered)
+          val start = s"// +SNIPPET [$key]"
+          val end = s"// -SNIPPET [$key]"
+          while (sublines.hasNext && !sublines.head.contains(start)) {
+            sublines.next() // drop lines until we find the start
+          }
+          val indent = sublines.headOption.map(_.indexOf(start)).getOrElse(-1)
+          if (indent != -1) {
+            sublines.next() // skip the start line
+            while (sublines.hasNext && !sublines.head.contains(end)) {
+              outputLines.append(sublines.next().drop(indent))
+            }
+          } else {
+            outputLines.append("")
+          }
         case (s"// +INCLUDE $rest", _) =>
           os.read.lines(mill.api.WorkspaceRoot.workspaceRoot / os.SubPath(rest)).foreach(outputLines.append)
 
@@ -50,11 +69,14 @@ def generateTutorial(sourcePath: os.Path, destPath: os.Path) =  {
 }
 def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) => Unit) =  {
   def dropExprPrefix(s: String) = s.split('.').drop(2).mkString(".")
+  def dropNTExprPrefix(s: String) = s.split('.').drop(3).mkString(".")
   val records = upickle.default.read[Seq[Record]](os.read.stream(mill.api.WorkspaceRoot.workspaceRoot / "out" / "recordedTests.json"))
+  val ntRecords = upickle.default.read[Seq[Record]](os.read.stream(mill.api.WorkspaceRoot.workspaceRoot / "out" / "recordedTestsNT.json"))
   val suiteDescriptions = upickle.default.read[Map[String, String]](os.read.stream(mill.api.WorkspaceRoot.workspaceRoot / "out" / "recordedSuiteDescriptions.json"))
     .map{case (k, v) => (dropExprPrefix(k), v)}
 
-  val rawScalaStrs = records.flatMap(r => Seq(r.queryCodeString) ++ r.resultCodeString)
+  val rawScalaStrs = (records ++ ntRecords)
+    .flatMap(r => Seq(r.queryCodeString) ++ r.resultCodeString)
   val formattedScalaStrs = {
     val tmps = rawScalaStrs.map(os.temp(_, suffix = ".scala"))
     scalafmtCallback(tmps, mill.api.WorkspaceRoot.workspaceRoot / ".scalafmt.conf")
@@ -124,6 +146,10 @@ def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) =
        |databases, due to differences in how each database parses SQL. These differences
        |are typically minor, and as long as you use the right `Dialect` for your database
        |ScalaSql should do the right thing for you.
+       |
+       |>**A note for users of `SimpleTable`**: The examples in this document assume usage of
+       |>`Table`, with a higher kinded type parameter on a case class. If you are using
+       |>`SimpleTable`, then the same code snippets should work by dropping `[Sc]`.
        |""".stripMargin
   )
   val recordsWithoutDuplicateSuites = records
@@ -132,15 +158,26 @@ def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) =
     .sortBy(_._2.head.suiteLine)
     .distinctBy { case (k, v) => dropExprPrefix(k)}
     .map{case (k, vs) => (dropExprPrefix(k), vs.map(r => r.copy(suiteName = dropExprPrefix(r.suiteName))))}
+  val ntRecordsWithoutDuplicateSuites = ntRecords
+    .groupBy(_.suiteName)
+    .toSeq
+    .sortBy(_._2.head.suiteLine)
+    .distinctBy { case (k, v) => dropNTExprPrefix(k)}
+    .map{case (k, vs) => (dropNTExprPrefix(k), vs.map(r => r.copy(suiteName = dropNTExprPrefix(r.suiteName))))}
+    .toMap
 
   for((suiteName, suiteGroup) <- recordsWithoutDuplicateSuites) {
     val seen = mutable.Set.empty[String]
     outputLines.append(s"## $suiteName")
     outputLines.append(suiteDescriptions(suiteName))
     var lastSeen = ""
-    for(r <- suiteGroup){
-
-      val prettyName = (r.suiteName +: r.testPath).mkString(".")
+    var remainingNTRecords = ntRecordsWithoutDuplicateSuites
+      .get(suiteName)
+      .getOrElse(Seq.empty).groupBy {r =>
+        val prettyName = (r.suiteName +: r.testPath).mkString(".")
+        prettyName
+      }
+    def addRecord(r: Record, prettyName: String) = {
       val titleOpt =
         if (prettyName == lastSeen) Some("----")
         else if (!seen(prettyName)) Some(s"### $prettyName")
@@ -151,21 +188,29 @@ def generateReference(dest: os.Path, scalafmtCallback: (Seq[os.Path], os.Path) =
         lastSeen = prettyName
         outputLines.append(
           s"""$title
-             |
-             |${dedent(r.docs, "")}
-             |
-             |```scala
-             |${scalafmt(r.queryCodeString)}
-             |```
-             |
-             |${sqlFormat(r.sqlString)}
-             |
-             |${renderResult(r.resultCodeString)}
-             |
-             |""".stripMargin
+            |
+            |${dedent(r.docs, "")}
+            |
+            |```scala
+            |${scalafmt(r.queryCodeString)}
+            |```
+            |
+            |${sqlFormat(r.sqlString)}
+            |
+            |${renderResult(r.resultCodeString)}
+            |
+            |""".stripMargin
         )
       }
     }
+    for(r <- suiteGroup){
+      val prettyName = (r.suiteName +: r.testPath).mkString(".")
+      addRecord(r, prettyName)
+      remainingNTRecords -= prettyName
+    }
+    for((prettyName, rs) <- remainingNTRecords; r <- rs) {
+      addRecord(r, prettyName)
+    }
   }
   os.write.over(dest, outputLines.mkString("\n"))
 }