loicknuchel

1. https://github.com/conduktor/scalaIO_2022/blob/main/src/main/elm/Rest/Main.elm#L11

You can use Browser.document instead as the Elm app takes the whole page

2. https://github.com/conduktor/scalaIO_2022/blob/main/src/main/elm/Rest/HttpRequests.elm#L149

I would put this in the Main.elm, replacing Msg. It will avoid the Cmd.map in the init for example. In functions in HttpRequests I would give the message as parameter. Ex:

listNames : (Result Http.Error (List TopicName) -> msg) -> Cmd msg

loicknuchel

// to execute in the console of https://www.postgresql.org/docs/current/catalog-pg-class.html
// and paste the copied result into https://azimutt.app ;)
function generateTableAml() {
  const url = window.location.href
  const table_schema = 'pg_catalog'
  const table_name = document.querySelector('h2.title .structname').textContent
  const table_description = document.querySelector('p').textContent
  const column_rows = Array.from(document.querySelector('.table-contents').querySelectorAll('tbody tr'))
  const columns = column_rows.map(r => {
    return {

loicknuchel

/*
    Using tailwind 3 CLI when generating dynamic classes can sometimes be quite painful as you never know which classes may be missing.
    Not anymore with this script!
    It gets your stylesheets, then all your classes in HTML and print classes that are present in HTML but not in stylesheets.
 */
function identifyMissingClasses() {
    getStyles().then(styles => {
        const classes = getClassCounts(document.getElementsByTagName('html')[0])
        const matches = matchClassesInStyles(styles, classes)
        const misses = filterMissingClasses(matches)

loicknuchel

import cats.effect.{ContextShift, IO}
import doobie.syntax.connectionio._
import doobie.syntax.string._
import doobie.util.Put
import doobie.util.fragment.Fragment
import doobie.util.fragment.Fragment.const0
import doobie.util.transactor.Transactor
import org.scalatest.BeforeAndAfterEach
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

loicknuchel

When building: https://github.com/loicknuchel/gospeak
If I do `sbt clean`, `sbt compile`, `sbt test` it works
But when I do `sbt clean test` it does not :(
Any idea how to troubleshoot ?

➜  gospeak git:(master) sbt clean test
[info] Loading global plugins from /home/lkn/.sbt/1.0/plugins
[info] Loading settings for project gospeak-build from plugins.sbt ...
[info] Loading project definition from /home/lkn/workspace/perso/gospeak/project
[info] Loading settings for project global from build.sbt ...

loicknuchel

trait Migrator[A, B] {
  def migrate(a: A): B
}

object Migrator {

  def apply[A, B](implicit m: Migrator[A, B]): Migrator[A, B] = m

  implicit def product[A, B, AR <: HList, BR <: HList, Common <: HList, Added <: HList, Unaligned <: HList]
  (implicit

loicknuchel

import java.sql.Timestamp
import java.time.Instant

import slick.basic.DatabaseConfig
import slick.jdbc.JdbcProfile
import slick.lifted.ProvenShape

import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success, Try}

loicknuchel

Testing started at 15:02 ...
Id.apply(7982e330-7daf-4cbd-a299-67af73ad24de)
Generated: Test(Id(7982e330-7daf-4cbd-a299-67af73ad24de),,464053996)
Id.apply(7982e330-7daf-4cbd)

TestFailedException was thrown during property evaluation.
  Message: TestSpec.this.Id.isValid(Id.this.value) was false Invalid Id: 7982e330-7daf-4cbd
  Location: (TestSpec.scala:16)
  Occurred when passed generated values (

loicknuchel

import org.scalatest.{FunSpec, Matchers}

object Implicits {

  implicit class SeqEitherExtension[E, A](val elt: Seq[Either[E, A]]) extends AnyVal {
    def partition: (Seq[E], Seq[A]) = {
      val (left, right) = elt.partition(_.isLeft)
      (left.collect { case Left(e) => e }, right.collect { case Right(a) => a })
    }
  }

loicknuchel

import scala.util.{Failure, Success, Try}

object ValidationMonad {
  sealed abstract class Validation[+A] {
    def isValid: Boolean
    def get: A
    def getOrElse[B >: A](default: => B): B
    def map[B](f: A => B): Validation[B]
    def flatMap[B](f: A => Validation[B]): Validation[B]
  }