cats.data.NonEmptyList Scala Examples

package com.avast.sst.pureconfig

import cats.data.NonEmptyList
import cats.effect.Sync
import cats.syntax.either._
import pureconfig.error.{ConfigReaderFailure, ConfigReaderFailures, ConvertFailure}
import pureconfig.{ConfigReader, ConfigSource}

import scala.reflect.ClassTag


  def makeOrRaise[F[_]: Sync, A: ConfigReader: ClassTag](source: ConfigSource): F[A] = Sync[F].delay(source.loadOrThrow[A])

  private def convertFailures(failures: ConfigReaderFailures): NonEmptyList[String] = {
    NonEmptyList(failures.head, failures.tail.toList).map(formatFailure)
  }

  private def formatFailure(configReaderFailure: ConfigReaderFailure): String = {
    configReaderFailure match {
      case convertFailure: ConvertFailure =>
        s"Invalid configuration ${convertFailure.path}: ${convertFailure.description}"
      case configFailure =>
        s"Invalid configuration : ${configFailure.description}"
    }
  }

} 

package io.asyncdb
package netty
package mysql

import cats.syntax.all._
import cats.effect._
import cats.effect.concurrent._
import cats.data.NonEmptyList
import io.netty.bootstrap.Bootstrap
import io.netty.channel.{Channel, ChannelInitializer}
import java.nio.charset.Charset
import protocol.client._
import protocol.server._

case class MySQLSocketConfig(
  bootstrap: Bootstrap,
  username: String,
  password: Option[String],
  database: Option[String],
  charset: Short,
  authMethod: Option[String]
) extends NettySocketConfig

class MySQLSocket[F[_]](
  config: MySQLSocketConfig,
  channelHolder: Deferred[F, Either[Throwable, Channel]],
  ref: MsgRef[F]
)(implicit F: Concurrent[F])
    extends NettySocket[F, Message](config, channelHolder) {

  def connect = {
    open.flatMap(_.read).as(this)
  }

  def disconnect = {
    close.void
  }

  def write(n: Message) = {
    channel.flatMap(_.write(n).to[F]).void
  }

  def read = ref.take.flatMap {
    case OrErr(value) =>
      F.fromEither(value)
    case v => F.pure(v)
  }
}

object MySQLSocket {
  def apply[F[_]: ConcurrentEffect](config: MySQLSocketConfig) = {
    for {
      msgRef   <- MVar[F].empty[Message]
      clientCS <- Deferred[F, Charset]
      initCtx = ChannelContext(
        ChannelState.Handshake.WaitHandshakeInit,
        clientCS
      )
      ctxRef <- Ref[F].of(initCtx)
      decoder = new FrameDecoder[F](config, ctxRef, msgRef)
      encoder = new FrameEncoder(config)
      initHandler = new ChannelInitializer[Channel] {
        override def initChannel(channel: Channel): Unit = {
          channel
            .pipeline()
            .addLast("MySQLFrameDecoder", decoder)
            .addLast("MySQLFrameEncoder", encoder)
        }
      }
      _ = config.bootstrap.handler(initHandler)
      channel <- Deferred[F, Either[Throwable, Channel]]
    } yield new MySQLSocket[F](config, channel, msgRef)
  }
} 

package ru.tinkoff.tschema.swagger
import cats.data.NonEmptyList
import derevo.Derivation
import magnolia.{CaseClass, Magnolia, SealedTrait}

sealed trait AsOpenApiParam[T] {
  def types: Map[String, DescribedType]
  def optional: AsOpenApiParam[Option[T]]
}

object AsOpenApiParam extends AsOpenParamInstances[AsOpenApiParam] with Derivation[AsOpenApiParam] {
  type Typeclass[x] = AsOpenApiParam[x]

  def apply[T](param: AsOpenApiParam[T]): AsOpenApiParam[T] = param

  def combine[T](ctx: CaseClass[Typeclass, T]): Typeclass[T] =
    AsMultiOpenApiParam[T](
      NonEmptyList
        .fromListUnsafe(ctx.parameters.toList)
        .flatMap { param =>
          param.typeclass match {
            case AsSingleOpenApiParam(t, r) => NonEmptyList.of(OpenApiParamField(param.label, t, r))
            case AsMultiOpenApiParam(ps)    => ps
          }
        }
    )

  def generate[T]: Typeclass[T] = macro Magnolia.gen[T]
  def instance[T]: Typeclass[T] = macro Magnolia.gen[T]
}

trait OpenApiParamInfo {
  def typ: SwaggerType
  def required: Boolean
  def types = typ.collectTypes
}
final case class OpenApiParamField(name: String, typ: SwaggerType, required: Boolean) extends OpenApiParamInfo

final case class AsMultiOpenApiParam[T](fields: NonEmptyList[OpenApiParamField]) extends AsOpenApiParam[T] {
  def parts: NonEmptyList[String]              = fields.map(_.name)
  def types                                    = fields.foldLeft(Map.empty[String, DescribedType])(_ ++ _.types)
  def optional: AsMultiOpenApiParam[Option[T]] = AsMultiOpenApiParam(fields.map(_.copy(required = false)))
}
final case class AsSingleOpenApiParam[T](typ: SwaggerType, required: Boolean = true)
    extends AsOpenApiParam[T] with OpenApiParamInfo {
  def optional: AsOpenApiParam[Option[T]] = AsSingleOpenApiParam(typ, required = false)
}

object AsSingleOpenApiParam extends AsOpenParamInstances[AsSingleOpenApiParam]

trait AsOpenParamInstances[TC[x] >: AsSingleOpenApiParam[x]] {
  final implicit def requiredParam[T](implicit typ: SwaggerTypeable[T]): TC[T]                 =
    AsSingleOpenApiParam[T](typ = typ.typ, required = true)
  final implicit def optParam[T](implicit param: AsOpenApiParam[T]): AsOpenApiParam[Option[T]] = param.optional
} 

package newts

import cats._
import cats.data.{NonEmptyList, Writer}
import cats.implicits._
import cats.kernel.laws.discipline.{EqTests, OrderTests}
import cats.laws.discipline.{AlternativeTests, ApplicativeErrorTests, CommutativeApplicativeTests, DistributiveTests, FunctorFilterTests, NonEmptyTraverseTests}
import cats.laws.discipline.arbitrary._
import fixtures.ShowTestClass

class BackwardsTest extends NewtsSuite {

  checkAll("Backwards[Option, Int]", EqTests[Backwards[Option, Int]].eqv)
  checkAll("Backwards[Option, Int]", OrderTests[Backwards[Option, Int]].order)
  checkAll("Backwards[Option, Int]", AlternativeTests[Backwards[Option, ?]].alternative[Int, Int, Int])
  checkAll("Backwards[Option, Int]", CommutativeApplicativeTests[Backwards[Option, ?]].commutativeApplicative[Int, Int, Int])
  checkAll("Backwards[Last, Int]]", DistributiveTests[Backwards[Last, ?]].distributive[Int, Int, Int, Option, Function0])
  checkAll("Backwards[List, Int]", FunctorFilterTests[Backwards[List, ?]].functorFilter[Int, Int, Int])
  checkAll("Backwards[NonEmptyList, Int]", NonEmptyTraverseTests[Backwards[NonEmptyList, ?]].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option])
  checkAll("Backwards[Either[String, ?], Int]", ApplicativeErrorTests[Backwards[Either[String, ?], ?], String].applicativeError[Int, Int, Int])

  test("applies actions in reverse order") {
    val f1 = Writer.tell(List(1)) *> Writer.value(1)
    val f2 = Writer.tell(List(2)) *> Writer.value(2)
    val f3 = Writer.tell(List(3)) *> Writer.value(3)

    val composed = (Backwards(f1), Backwards(f2), Backwards(f3)).mapN(Tuple3.apply).forwards

    composed.value shouldEqual ((1, 2, 3))
    composed.written shouldEqual List(3, 2, 1)
  }

  test("show") {
    Backwards(Option("aString")).show shouldEqual "Backwards(Some(aString))"
    Backwards(List(42, 24)).show shouldEqual "Backwards(List(42, 24))"
    Backwards(Writer("log", new ShowTestClass)).show shouldEqual s"Backwards((log,${ShowTestClass.show}))"
  }
} 

package newts

import cats._
import cats.data.{NonEmptyList, Writer}
import cats.implicits._
import cats.kernel.laws.discipline.{EqTests, OrderTests}
import cats.laws.discipline.arbitrary._
import cats.laws.discipline.{AlternativeTests, BimonadTests, CommutativeMonadTests, DistributiveTests, FunctorFilterTests, MonadErrorTests, NonEmptyTraverseTests}
import fixtures.ShowTestClass

class ReverseTest extends NewtsSuite {

  checkAll("Reverse[Option, Int]", EqTests[Reverse[Option, Int]].eqv)
  checkAll("Reverse[Option, Int]", OrderTests[Reverse[Option, Int]].order)
  checkAll("Reverse[Option, Int]", AlternativeTests[Reverse[Option, ?]].alternative[Int, Int, Int])
  checkAll("Reverse[Option, Int]", CommutativeMonadTests[Reverse[Option, ?]].commutativeMonad[Int, Int, Int])
  checkAll("Reverse[Last, Int]]", DistributiveTests[Reverse[Last, ?]].distributive[Int, Int, Int, Option, Function0])
  checkAll("Reverse[List, Int]", FunctorFilterTests[Reverse[List, ?]].functorFilter[Int, Int, Int])
  checkAll("Reverse[NonEmptyList, Int]", BimonadTests[Reverse[NonEmptyList, ?]].bimonad[Int, Int, Int])
  checkAll("Reverse[NonEmptyList, Int]", NonEmptyTraverseTests[Reverse[NonEmptyList, ?]].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option])
  checkAll("Reverse[Either[String, ?], Int]", MonadErrorTests[Reverse[Either[String, ?], ?], String].monadError[Int, Int, Int])

  type RevList[A] = Reverse[List, A]

  test("is folded in reverse order") {
    Reverse(List("a", "b", "c")).foldLeft("")(_ ++ _) shouldBe "cba"
    Reverse(List("a", "b", "c")).foldRight(Eval.now(""))((x, y) => Eval.now(x ++ y.value)).value shouldBe "cba"
  }

  test("is traversed in reverse order") {
    def write(n: Int): Writer[List[Int], Int] = Writer.tell(List(n)) *> Writer.value(n)

    val result: Writer[List[Int], List[Int]] = Reverse(List(1,2,3)).traverse(write).map(_.getReverse)

    result.value shouldEqual List(1,2,3)
    result.written shouldEqual List(3,2,1)
  }

  test("show") {
    Reverse(Option("aString")).show shouldEqual "Reverse(Some(aString))"
    Reverse(List(42, 24)).show shouldEqual "Reverse(List(42, 24))"
    Reverse(Writer("log", new ShowTestClass)).show shouldEqual s"Reverse((log,${ShowTestClass.show}))"
  }
} 

package newts

import cats.Id
import cats.data.NonEmptyList
import cats.kernel.laws.discipline.{EqTests, MonoidTests, SemigroupTests}
import cats.laws.discipline.{DistributiveTests, MonadTests, TraverseTests}
import cats.laws.discipline.arbitrary._
import fixtures.ShowTestClass

class DualTest extends NewtsSuite {

  checkAll("Dual[NonEmptyList[Int]]", SemigroupTests[Dual[NonEmptyList[Int]]].semigroup)
  checkAll("Dual[List[Int]]"        , MonoidTests[Dual[List[Int]]].monoid)
  checkAll("Dual[Int]"              , EqTests[Dual[Int]].eqv)
  checkAll("Dual[Int]"              , MonadTests[Dual].monad[Int, Int, Int])
  checkAll("Dual[Int]"              , TraverseTests[Dual].traverse[Int, Int, Int, Int, Option, Option])
  checkAll("Dual[Int]"              , DistributiveTests[Dual].distributive[Int, Int, Int, Option, Id])

  test("combine"){
    val xs = NonEmptyList.of(1,2)
    val ys = NonEmptyList.of(3,4)

    xs.asDual |+| ys.asDual shouldEqual (ys |+| xs).asDual
  }

  test("show") {
    Dual("aString").show shouldEqual "Dual(aString)"
    Dual(42).show shouldEqual "Dual(42)"
    Dual(new ShowTestClass).show shouldEqual s"Dual(${ShowTestClass.show})"
  }

  test("dual of first is last"){
    val xs = NonEmptyList(1, List(2,3,4,5))

    xs.reduceMap(_.asFirst.asDual).getDual.getFirst shouldEqual 5
  }
} 

package zio.interop.test

import cats.data.NonEmptyList
import cats.{ Bifunctor, Monad, MonadError, SemigroupK }
import zio._
import zio.interop.catz.core._
import zio.stream.interop.catz.core._
import zio.stream.{ Stream, ZStream }
import zio.test.Assertion._
import zio.test.{ DefaultRunnableSpec, test, _ }

object CoreSummonSpecextends extends DefaultRunnableSpec {
  override def spec =
    suite("summons from catz.core work with only a cats-core dependency")(
      test("ZIO instances") {
        val monad      = implicitly[Monad[UIO]]
        val monadError = implicitly[MonadError[Task, Throwable]]
        val semigroupK = implicitly[SemigroupK[IO[NonEmptyList[Unit], ?]]]
        val bifunctor  = implicitly[Bifunctor[IO]]

        monad.map(ZIO.unit)(identity)
        monadError.map(ZIO.unit)(identity)
        semigroupK.combineK(ZIO.unit, ZIO.unit)
        bifunctor.leftMap(ZIO.fromOption(None))(identity)

        assert(())(anything)
      },
      test("ZManaged instances") {
        val monad      = implicitly[Monad[ZManaged[Any, Nothing, ?]]]
        val monadError = implicitly[MonadError[Managed[Throwable, ?], Throwable]]
        val semigroupK = implicitly[SemigroupK[Managed[Nothing, ?]]]
        val bifunctor  = implicitly[Bifunctor[Managed]]

        monad.map(ZManaged.unit)(identity)
        monadError.map(ZManaged.unit)(identity)
        semigroupK.combineK(ZManaged.unit, ZManaged.unit)
        bifunctor.leftMap(ZManaged.fail(()))(identity)

        assert(())(anything)
      },
      test("ZStream instances") {
        val monad      = implicitly[Monad[ZStream[Any, Nothing, ?]]]
        val monadError = implicitly[MonadError[Stream[Throwable, ?], Throwable]]
        val semigroupK = implicitly[SemigroupK[Stream[Nothing, ?]]]
        val bifunctor  = implicitly[Bifunctor[Stream]]

        monad.map(ZStream.unit)(identity)
        monadError.map(ZStream.unit)(identity)
        semigroupK.combineK(ZStream.unit, ZStream.unit)
        bifunctor.leftMap(ZStream.fail(()))(identity)

        assert(())(anything)
      }
    )

} 

package sttp.tapir.codec.cats

import cats.data.{NonEmptyChain, NonEmptyList, NonEmptySet}
import sttp.tapir.{Schema, SchemaType}
import sttp.tapir._

import scala.collection.immutable.SortedSet

trait TapirCodecCats {

  private def nonEmpty[T, C[X] <: Iterable[X]]: Validator.Primitive[C[T]] = Validator.minSize[T, C](1)

  private def iterableAndNonEmpty[T, C[X] <: Iterable[X]](implicit v: Validator[T]): Validator[C[T]] =
    v.asIterableElements[C].and(nonEmpty)

  implicit def validatorNel[T: Validator]: Validator[NonEmptyList[T]] =
    iterableAndNonEmpty[T, List].contramap(_.toList)

  implicit def validatorNec[T: Validator]: Validator[NonEmptyChain[T]] =
    iterableAndNonEmpty[T, List].contramap(_.toChain.toList)

  implicit def validatorNes[T: Validator]: Validator[NonEmptySet[T]] =
    iterableAndNonEmpty[T, Set].contramap(_.toSortedSet)

  implicit def schemaForNel[T: Schema]: Schema[NonEmptyList[T]] =
    Schema[NonEmptyList[T]](SchemaType.SArray(implicitly[Schema[T]])).copy(isOptional = false)

  implicit def schemaForNec[T: Schema]: Schema[NonEmptyChain[T]] =
    Schema[NonEmptyChain[T]](SchemaType.SArray(implicitly[Schema[T]])).copy(isOptional = false)

  implicit def schemaForNes[T: Schema]: Schema[NonEmptySet[T]] =
    Schema[NonEmptySet[T]](SchemaType.SArray(implicitly[Schema[T]])).copy(isOptional = false)

  implicit def codecForNonEmptyList[L, H, CF <: CodecFormat](implicit c: Codec[L, List[H], CF]): Codec[L, NonEmptyList[H], CF] =
    c.modifySchema(_.copy(isOptional = false))
      .validate(nonEmpty)
      .mapDecode { l => DecodeResult.fromOption(NonEmptyList.fromList(l)) }(_.toList)

  implicit def codecForNonEmptyChain[L, H, CF <: CodecFormat](implicit c: Codec[L, List[H], CF]): Codec[L, NonEmptyChain[H], CF] =
    c.modifySchema(_.copy(isOptional = false))
      .validate(nonEmpty)
      .mapDecode { l => DecodeResult.fromOption(NonEmptyChain.fromSeq(l)) }(_.toNonEmptyList.toList)

  implicit def codecForNonEmptySet[L, H: Ordering, CF <: CodecFormat](implicit c: Codec[L, Set[H], CF]): Codec[L, NonEmptySet[H], CF] =
    c.modifySchema(_.copy(isOptional = false))
      .validate(nonEmpty)
      .mapDecode { set => DecodeResult.fromOption(NonEmptySet.fromSet(SortedSet(set.toSeq: _*))) }(_.toSortedSet)
} 

package sttp.tapir.server.play

import akka.actor.ActorSystem
import cats.data.NonEmptyList
import cats.effect.{IO, Resource}
import play.api.Mode
import play.api.mvc.{Handler, RequestHeader}
import play.api.routing.Router
import play.api.routing.Router.Routes
import play.core.server.{DefaultAkkaHttpServerComponents, ServerConfig}
import sttp.tapir.Endpoint
import sttp.tapir.server.tests.ServerTests
import sttp.tapir.server.{DecodeFailureHandler, ServerDefaults, ServerEndpoint}
import sttp.tapir.tests.{Port, PortCounter}

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Await, Future}
import scala.reflect.ClassTag

class PlayServerTests extends ServerTests[Future, Nothing, Router.Routes] {
  override def multipleValueHeaderSupport: Boolean = false
  override def multipartInlineHeaderSupport: Boolean = false
  override def streamingSupport: Boolean = false

  private implicit val actorSystem: ActorSystem = ActorSystem()

  override protected def afterAll(): Unit = {
    Await.result(actorSystem.terminate(), 5.seconds)
    super.afterAll()
  }

  override def pureResult[T](t: T): Future[T] = Future.successful(t)

  override def suspendResult[T](t: => T): Future[T] = Future(t)

  override def route[I, E, O](
      e: ServerEndpoint[I, E, O, Nothing, Future],
      decodeFailureHandler: Option[DecodeFailureHandler]
  ): Routes = {
    implicit val serverOptions: PlayServerOptions =
      PlayServerOptions.default.copy(decodeFailureHandler = decodeFailureHandler.getOrElse(ServerDefaults.decodeFailureHandler))
    e.toRoute
  }

  override def routeRecoverErrors[I, E <: Throwable, O](e: Endpoint[I, E, O, Nothing], fn: I => Future[O])(implicit
      eClassTag: ClassTag[E]
  ): Routes = {
    e.toRouteRecoverErrors(fn)
  }

  override def server(routes: NonEmptyList[Routes], port: Port): Resource[IO, Unit] = {
    val components = new DefaultAkkaHttpServerComponents {
      override lazy val serverConfig: ServerConfig = ServerConfig(port = Some(port), address = "127.0.0.1", mode = Mode.Test)
      override def router: Router =
        Router.from(
          routes.reduce((a: Routes, b: Routes) => {
            val handler: PartialFunction[RequestHeader, Handler] = {
              case request => a.applyOrElse(request, b)
            }

            handler
          })
        )
    }
    val bind = IO {
      components.server
    }
    Resource.make(bind)(s => IO(s.stop())).map(_ => ())
  }

  override val portCounter: PortCounter = new PortCounter(38000)
} 

package sttp.tapir.server.vertx

import cats.data.NonEmptyList
import cats.effect.{IO, Resource}
import cats.implicits._
import io.vertx.lang.scala.VertxExecutionContext
import io.vertx.scala.core.Vertx
import io.vertx.scala.core.http.HttpServerOptions
import io.vertx.scala.ext.web.{Route, Router}
import org.scalatest.BeforeAndAfterEach
import sttp.tapir._
import sttp.tapir.server.tests.ServerTests
import sttp.tapir.server.{DecodeFailureHandler, ServerDefaults, ServerEndpoint}
import sttp.tapir.tests.{Port, PortCounter}

import scala.concurrent.Future
import scala.reflect.ClassTag

class VertxServerTests extends ServerTests[Future, String, Router => Route] with BeforeAndAfterEach {

  implicit val options: VertxEndpointOptions = VertxEndpointOptions()
    .logWhenHandled(true)
    .logAllDecodeFailures(true)

  override def multipartInlineHeaderSupport: Boolean = false // README: doesn't seem supported but I may be wrong

  protected var vertx: Vertx = _

  override def beforeAll(): Unit = {
    super.beforeAll()
    vertx = Vertx.vertx()
  }

  override def afterAll(): Unit = {
    super.afterAll()
    vertx.close()
  }

  override def pureResult[T](t: T): Future[T] = Future.successful(t)
  override def suspendResult[T](t: => T): Future[T] = Future(t)(VertxExecutionContext(vertx.getOrCreateContext()))

  override def route[I, E, O](
      e: ServerEndpoint[I, E, O, String, Future],
      decodeFailureHandler: Option[DecodeFailureHandler]
  ): Router => Route =
    e.route(options.copy(decodeFailureHandler.getOrElse(ServerDefaults.decodeFailureHandler)))

  override def routeRecoverErrors[I, E <: Throwable, O](e: Endpoint[I, E, O, String], fn: I => Future[O])(implicit
      eClassTag: ClassTag[E]
  ): Router => Route =
    e.routeRecoverErrors(fn)

  override def server(routes: NonEmptyList[Router => Route], port: Port): Resource[IO, Unit] = {
    val router = Router.router(vertx)
    val server = vertx.createHttpServer(HttpServerOptions().setPort(port)).requestHandler(router)
    val listenIO = IO.fromFuture(IO(server.listenFuture(port)))
    routes.toList.foreach(_.apply(router))
    Resource.make(listenIO)(s => IO(s.closeFuture())).void
  }

  override lazy val portCounter: PortCounter = new PortCounter(54000)

} 

package sttp.tapir.server.akkahttp

import cats.implicits._
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Route
import akka.http.scaladsl.server.Directives
import akka.http.scaladsl.server.Directives._
import cats.data.NonEmptyList
import cats.effect.{IO, Resource}
import sttp.client._
import com.typesafe.scalalogging.StrictLogging
import sttp.tapir.{Endpoint, endpoint, stringBody}
import sttp.tapir.server.tests.ServerTests
import sttp.tapir._
import sttp.tapir.server.{DecodeFailureHandler, ServerDefaults, ServerEndpoint}
import sttp.tapir.tests.{Port, PortCounter}

import scala.concurrent.duration._
import scala.concurrent.{Await, Future}
import scala.reflect.ClassTag

class AkkaHttpServerTests extends ServerTests[Future, AkkaStream, Route] with StrictLogging {
  private implicit var actorSystem: ActorSystem = _

  override protected def beforeAll(): Unit = {
    super.beforeAll()
    actorSystem = ActorSystem()
  }

  override protected def afterAll(): Unit = {
    Await.result(actorSystem.terminate(), 5.seconds)
    super.afterAll()
  }

  override def route[I, E, O](
      e: ServerEndpoint[I, E, O, AkkaStream, Future],
      decodeFailureHandler: Option[DecodeFailureHandler] = None
  ): Route = {
    implicit val serverOptions: AkkaHttpServerOptions = AkkaHttpServerOptions.default.copy(
      decodeFailureHandler = decodeFailureHandler.getOrElse(ServerDefaults.decodeFailureHandler)
    )
    e.toRoute
  }

  override def routeRecoverErrors[I, E <: Throwable, O](e: Endpoint[I, E, O, AkkaStream], fn: I => Future[O])(implicit
      eClassTag: ClassTag[E]
  ): Route = {
    e.toRouteRecoverErrors(fn)
  }

  override def server(routes: NonEmptyList[Route], port: Port): Resource[IO, Unit] = {
    val bind = IO.fromFuture(IO(Http().bindAndHandle(routes.toList.reduce(_ ~ _), "localhost", port)))
    Resource.make(bind)(binding => IO.fromFuture(IO(binding.unbind())).void).void
  }

  override def pureResult[T](t: T): Future[T] = Future.successful(t)
  override def suspendResult[T](t: => T): Future[T] = {
    import scala.concurrent.ExecutionContext.Implicits.global
    Future { t }
  }

  override lazy val portCounter: PortCounter = new PortCounter(57000)

  if (testNameFilter.isEmpty) {
    test("endpoint nested in a path directive") {
      val e = endpoint.get.in("test" and "directive").out(stringBody).serverLogic(_ => pureResult("ok".asRight[Unit]))
      val port = portCounter.next()
      val route = Directives.pathPrefix("api")(e.toRoute)
      server(NonEmptyList.of(route), port).use { _ =>
        basicRequest.get(uri"http://localhost:$port/api/test/directive").send().map(_.body shouldBe Right("ok"))
      }.unsafeRunSync
    }
  }
} 

package sttp.tapir.server.finatra

import cats.data.NonEmptyList
import cats.effect.{ContextShift, IO, Resource, Timer}
import com.github.ghik.silencer.silent
import com.twitter.finagle.http.Request
import com.twitter.finatra.http.filters.{AccessLoggingFilter, ExceptionMappingFilter}
import com.twitter.finatra.http.{Controller, EmbeddedHttpServer, HttpServer}
import com.twitter.finatra.http.routing.HttpRouter
import com.twitter.util.{Future, FuturePool}
import sttp.tapir.Endpoint
import sttp.tapir.server.{DecodeFailureHandler, ServerDefaults, ServerEndpoint}
import sttp.tapir.server.tests.ServerTests
import sttp.tapir.tests.{Port, PortCounter}

import scala.concurrent.ExecutionContext
import scala.reflect.ClassTag
import scala.concurrent.duration._

class FinatraServerTests extends ServerTests[Future, Nothing, FinatraRoute] {
  override def streamingSupport: Boolean = false

  private val futurePool = FuturePool.unboundedPool

  implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
  implicit val contextShift: ContextShift[IO] = IO.contextShift(ec)
  implicit val timer: Timer[IO] = IO.timer(ec)

  override def pureResult[T](t: T): Future[T] = Future.value(t)

  override def suspendResult[T](t: => T): Future[T] =
    futurePool {
      t
    }

  override def route[I, E, O](
      e: ServerEndpoint[I, E, O, Nothing, Future],
      decodeFailureHandler: Option[DecodeFailureHandler] = None
  ): FinatraRoute = {
    implicit val serverOptions: FinatraServerOptions =
      FinatraServerOptions.default.copy(decodeFailureHandler = decodeFailureHandler.getOrElse(ServerDefaults.decodeFailureHandler))
    e.toRoute
  }

  override def routeRecoverErrors[I, E <: Throwable, O](e: Endpoint[I, E, O, Nothing], fn: I => Future[O])(implicit
      eClassTag: ClassTag[E]
  ): FinatraRoute = {
    e.toRouteRecoverErrors(fn)
  }

  override def server(routes: NonEmptyList[FinatraRoute], port: Port): Resource[IO, Unit] = FinatraServerTests.server(routes, port)

  override lazy val portCounter: PortCounter = new PortCounter(58000)
}

object FinatraServerTests {
  def server(routes: NonEmptyList[FinatraRoute], port: Port)(implicit ioTimer: Timer[IO]): Resource[IO, Unit] = {
    def waitUntilHealthy(s: EmbeddedHttpServer, count: Int): IO[EmbeddedHttpServer] =
      if (s.isHealthy) IO.pure(s)
      else if (count > 1000) IO.raiseError(new IllegalStateException("Server unhealthy"))
      else IO.sleep(10.milliseconds).flatMap(_ => waitUntilHealthy(s, count + 1))

    val bind = IO {
      class TestController extends Controller with TapirController {
        routes.toList.foreach(addTapirRoute)
      }

      class TestServer extends HttpServer {
        @silent("discarded")
        override protected def configureHttp(router: HttpRouter): Unit = {
          router
            .filter[AccessLoggingFilter[Request]]
            .filter[ExceptionMappingFilter[Request]]
            .add(new TestController)
        }
      }

      val server = new EmbeddedHttpServer(
        new TestServer,
        Map(
          "http.port" -> s":$port"
        ),
        // in the default implementation waitForWarmup suspends the thread for 1 second between healthy checks
        // we improve on that by checking every 10ms
        waitForWarmup = false
      )
      server.start()
      server
    }.flatMap(waitUntilHealthy(_, 0))

    Resource
      .make(bind)(httpServer => IO(httpServer.close()))
      .map(_ => ())
  }
} 

package sttp.tapir.server.finatra.cats

import cats.data.NonEmptyList
import cats.effect.{ContextShift, IO, Resource, Timer}
import sttp.tapir.Endpoint
import sttp.tapir.server.finatra.{FinatraRoute, FinatraServerOptions, FinatraServerTests}
import sttp.tapir.server.tests.ServerTests
import sttp.tapir.server.{DecodeFailureHandler, ServerDefaults, ServerEndpoint}
import sttp.tapir.tests.{Port, PortCounter}

import scala.concurrent.ExecutionContext
import scala.reflect.ClassTag

class FinatraServerCatsTests extends ServerTests[IO, Nothing, FinatraRoute] {
  override def streamingSupport: Boolean = false

  implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
  implicit val contextShift: ContextShift[IO] = IO.contextShift(ec)
  implicit val timer: Timer[IO] = IO.timer(ec)

  override def pureResult[T](t: T): IO[T] = IO.pure(t)
  override def suspendResult[T](t: => T): IO[T] = IO.apply(t)

  override def route[I, E, O](
      e: ServerEndpoint[I, E, O, Nothing, IO],
      decodeFailureHandler: Option[DecodeFailureHandler] = None
  ): FinatraRoute = {
    implicit val serverOptions: FinatraServerOptions =
      FinatraServerOptions.default.copy(decodeFailureHandler = decodeFailureHandler.getOrElse(ServerDefaults.decodeFailureHandler))
    e.toRoute
  }

  override def routeRecoverErrors[I, E <: Throwable, O](e: Endpoint[I, E, O, Nothing], fn: I => IO[O])(implicit
      eClassTag: ClassTag[E]
  ): FinatraRoute = e.toRouteRecoverErrors(fn)

  override def server(routes: NonEmptyList[FinatraRoute], port: Port): Resource[IO, Unit] = FinatraServerTests.server(routes, port)

  override lazy val portCounter: PortCounter = new PortCounter(59000)
} 

package sttp.tapir.server.http4s

import cats.data.{Kleisli, NonEmptyList}
import cats.effect._
import cats.implicits._
import org.http4s.server.Router
import org.http4s.server.blaze.BlazeServerBuilder
import org.http4s.syntax.kleisli._
import org.http4s.{EntityBody, HttpRoutes, Request, Response}
import sttp.tapir.server.tests.ServerTests
import sttp.tapir.Endpoint
import sttp.tapir._
import sttp.client._
import sttp.tapir.server.{DecodeFailureHandler, ServerDefaults, ServerEndpoint}
import sttp.tapir.tests.{Port, PortCounter}

import scala.concurrent.ExecutionContext
import scala.reflect.ClassTag

class Http4sServerTests extends ServerTests[IO, EntityBody[IO], HttpRoutes[IO]] {
  implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
  implicit val contextShift: ContextShift[IO] = IO.contextShift(ec)
  implicit val timer: Timer[IO] = IO.timer(ec)

  override def pureResult[T](t: T): IO[T] = IO.pure(t)
  override def suspendResult[T](t: => T): IO[T] = IO.apply(t)

  override def route[I, E, O](
      e: ServerEndpoint[I, E, O, EntityBody[IO], IO],
      decodeFailureHandler: Option[DecodeFailureHandler] = None
  ): HttpRoutes[IO] = {
    implicit val serverOptions: Http4sServerOptions[IO] = Http4sServerOptions
      .default[IO]
      .copy(
        decodeFailureHandler = decodeFailureHandler.getOrElse(ServerDefaults.decodeFailureHandler)
      )
    e.toRoutes
  }

  override def routeRecoverErrors[I, E <: Throwable, O](e: Endpoint[I, E, O, EntityBody[IO]], fn: I => IO[O])(implicit
      eClassTag: ClassTag[E]
  ): HttpRoutes[IO] = {
    e.toRouteRecoverErrors(fn)
  }

  override def server(routes: NonEmptyList[HttpRoutes[IO]], port: Port): Resource[IO, Unit] = {
    val service: Kleisli[IO, Request[IO], Response[IO]] = routes.reduceK.orNotFound

    BlazeServerBuilder[IO](ExecutionContext.global)
      .bindHttp(port, "localhost")
      .withHttpApp(service)
      .resource
      .void
  }

  override lazy val portCounter: PortCounter = new PortCounter(56000)

  if (testNameFilter.isEmpty) {
    test("should work with a router and routes in a context") {
      val e = endpoint.get.in("test" / "router").out(stringBody).serverLogic(_ => IO.pure("ok".asRight[Unit]))
      val routes = e.toRoutes
      val port = portCounter.next()

      BlazeServerBuilder[IO](ExecutionContext.global)
        .bindHttp(port, "localhost")
        .withHttpApp(Router("/api" -> routes).orNotFound)
        .resource
        .use { _ => basicRequest.get(uri"http://localhost:$port/api/test/router").send().map(_.body shouldBe Right("ok")) }
        .unsafeRunSync()
    }
  }
} 

package com.wavesplatform.settings.utils

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import com.typesafe.config.{Config, ConfigException}
import com.wavesplatform.transaction.assets.exchange.AssetPair
import net.ceedubs.ficus.Ficus._
import net.ceedubs.ficus.readers.ValueReader

import scala.jdk.CollectionConverters._
import scala.util.Try

object ConfigSettingsValidator {

  type ErrorsListOr[A] = ValidatedNel[String, A]

  def apply(config: Config): ConfigSettingsValidator = new ConfigSettingsValidator(config)

  implicit class ErrorListOrOps[A](validatedValue: ErrorsListOr[A]) {
    def getValueOrThrowErrors: A = validatedValue valueOr (errorsAcc => throw new Exception(errorsAcc.mkString_(", ")))
  }

  object AdhocValidation {
    def validateAssetPairKey(key: String): Validated[String, AssetPair] =
      Validated.fromTry(AssetPair.fromString(key)) leftMap (_ => s"Can't parse asset pair '$key'")
  }
}

class ConfigSettingsValidator(config: Config) {

  import ConfigSettingsValidator.ErrorsListOr

  private def createError[T](settingName: String, errorMsg: String, showError: Boolean = true, showValue: Boolean = true): NonEmptyList[String] = {

    lazy val value = config.getValue(settingName).unwrapped

    lazy val msg = (showValue, showError) match {
      case (true, true)  => s"$value ($errorMsg)"
      case (true, false) => s"$value"
      case (false, true) => s"$errorMsg"
      case _             => ""
    }

    NonEmptyList.one(s"Invalid setting $settingName value: $msg")
  }

  def validate[T: ValueReader](settingName: String, showError: Boolean = false): ErrorsListOr[T] = {
    Validated fromTry Try(config.as[T](settingName)) leftMap (ex => createError(settingName, ex.getMessage, showError))
  }

  def validateByPredicate[T: ValueReader](settingName: String)(predicate: T => Boolean, errorMsg: String): ErrorsListOr[T] = {
    validate[T](settingName, showError = true).ensure(createError(settingName, errorMsg))(predicate)
  }

  def validatePercent(settingName: String): ErrorsListOr[Double] = {
    validateByPredicate[Double](settingName)(p => 0 < p && p <= 100, "required 0 < percent <= 100")
  }

  def validateList[T: ValueReader](settingName: String): ErrorsListOr[List[T]] = {
    config
      .getList(settingName)
      .asScala
      .toList
      .zipWithIndex
      .traverse {
        case (cfg, index) =>
          val elemPath = s"$settingName.$index"
          Validated fromTry Try(cfg.atPath(elemPath).as[T](elemPath)) leftMap (ex => List(ex.getMessage))
      }
      .leftMap(errorsInList => createError(settingName, errorsInList.mkString(", "), showValue = false))
  }

  def validateMap[K, V: ValueReader](settingName: String)(keyValidator: String => Validated[String, K]): ErrorsListOr[Map[K, V]] = {
    config
      .getConfig(settingName)
      .root()
      .entrySet()
      .asScala
      .toList
      .traverse { entry =>
        val elemPath = s"$settingName.${entry.getKey}"
        val k        = keyValidator(entry.getKey).leftMap(List(_))
        val v        = Validated fromTry Try(entry.getValue.atPath(elemPath).as[V](elemPath)) leftMap (ex => List(ex.getMessage))
        k.product(v)
      }
      .map(_.toMap)
      .leftMap(errorsInList => createError(settingName, errorsInList.mkString(", "), showValue = false))
  }

  def validateWithDefault[T: ValueReader](settingName: String, defaultValue: T, showError: Boolean = false): ErrorsListOr[T] = {
    Validated
      .fromTry(Try(config.as[T](settingName)).recover { case _: ConfigException.Missing => defaultValue })
      .leftMap(ex => createError(settingName, ex.getMessage, showError))
  }

  def validateByPredicateWithDefault[T: ValueReader](
      settingName: String)(predicate: T => Boolean, errorMsg: String, defaultValue: T): ErrorsListOr[T] = {
    validateWithDefault[T](settingName, defaultValue, showError = true).ensure(createError(settingName, errorMsg))(predicate)
  }
} 

package com.avast.sst.pureconfig

import cats.data.NonEmptyList
import cats.effect.SyncIO
import org.scalatest.funsuite.AnyFunSuite
import pureconfig.error.ConfigReaderException
import pureconfig.generic.semiauto.deriveReader
import pureconfig.{ConfigReader, ConfigSource}

class PureConfigModuleTest extends AnyFunSuite {

  private val source = ConfigSource.string("""|number = 123
                                              |string = "test"""".stripMargin)

  private case class TestConfig(number: Int, string: String)

  implicit private val configReader: ConfigReader[TestConfig] = deriveReader

  test("Simple configuration loading") {
    assert(PureConfigModule.make[SyncIO, TestConfig](source).unsafeRunSync() === Right(TestConfig(123, "test")))
    assert(
      PureConfigModule.make[SyncIO, TestConfig](ConfigSource.empty).unsafeRunSync() === Left(
        NonEmptyList("Invalid configuration : Key not found: 'number'.", List("Invalid configuration : Key not found: 'string'."))
      )
    )
  }

  test("Configuration loading with exceptions") {
    assert(PureConfigModule.makeOrRaise[SyncIO, TestConfig](source).unsafeRunSync() === TestConfig(123, "test"))
    assertThrows[ConfigReaderException[TestConfig]] {
      PureConfigModule.makeOrRaise[SyncIO, TestConfig](ConfigSource.empty).unsafeRunSync()
    }
  }

} 

package org.aws4s.dynamodb

import cats.data.NonEmptyList
import org.aws4s.core.{AggregateParamRenderer, AggregateParamValidator}

case class KeySchema(elements: NonEmptyList[KeySchemaElement])
    extends DynamoDbAggregateParam(
      KeySchema.name,
      elements.toList,
      AggregateParamValidator.sizeInRangeInclusive(1, 2),
      AggregateParamRenderer.jsonArray,
    )

object KeySchema {
  val name: String = "KeySchema"
} 

package org.aws4s.dynamodb

import cats.data.NonEmptyList
import cats.effect.Effect
import io.circe.{Decoder, Json}
import org.aws4s.Region
import org.aws4s.core.{Command, Param}

private[dynamodb] case class CreateTable[F[_]: Effect](
    region:                Region,
    indices:               NonEmptyList[Index],
    tableName:             TableName,
    provisionedThroughput: ProvisionedThroughput,
) extends DynamoDbCommand[F, CreateTableSuccess] {

  override def action: String = "CreateTable"

  override def params: List[Param[Json]] = {
    val attributeDefinitions = AttributeDefinitions(indices.map(ix => AttributeDefinition(ix.attributeName, ix.attributeType)))
    val keySchema            = KeySchema(indices.map(ix            => KeySchemaElement(ix.attributeName, ix.keyType)))

    List(attributeDefinitions, tableName, keySchema, provisionedThroughput)
  }

  override val validator: Command.Validator[Json] = _ => None
}

case class CreateTableSuccess(tableDescription: TableDescription)

object CreateTableSuccess {
  implicit val decoder: Decoder[CreateTableSuccess] =
    Decoder.forProduct1(TableDescription.name)(CreateTableSuccess.apply)
} 

package org.aws4s.dynamodb

import cats.data.NonEmptyList
import cats.effect.Effect
import io.circe.Json
import org.aws4s.core.Service
import org.aws4s.{Credentials, Region}
import org.http4s.client.Client
import org.aws4s.core.ExtraEntityDecoderInstances._

case class DynamoDb[F[_]: Effect](client: F[Client[F]], region: Region, credentials: () => Credentials) extends Service[F, Json] {

  def createTable(tableName: TableName, indices: NonEmptyList[Index], provisionedThroughput: ProvisionedThroughput): F[CreateTableSuccess] =
    run {
      CreateTable(region, indices, tableName, provisionedThroughput)
    }

  def deleteTable(tableName: TableName): F[DeleteTableSuccess] =
    run {
      DeleteTable(region, tableName)
    }
} 

package org.aws4s.dynamodb

import cats.data.NonEmptyList
import org.aws4s.core.{AggregateParamRenderer, AggregateParamValidator}

case class AttributeDefinitions(value: NonEmptyList[AttributeDefinition])
    extends DynamoDbAggregateParam(
      AttributeDefinitions.name,
      value.toList,
      AggregateParamValidator.all,
      AggregateParamRenderer.jsonArray
    )

object AttributeDefinitions {
  val name: String = "AttributeDefinitions"
} 

package org.aws4s.core

import cats.data.NonEmptyList
import cats.effect.{Effect, Sync}
import io.circe.Json
import org.http4s.{EntityDecoder, MediaRange, Message}
import org.http4s.scalaxml._
import org.http4s.circe._

private[aws4s] sealed trait ResponseContent {
  final def tryParse[A](pf: PartialFunction[ResponseContent, Option[A]]): Option[A] =
    pf.orElse[ResponseContent, Option[A]]({ case _ => None })(this)
}

private[aws4s] case class XmlContent(elem:    scala.xml.Elem) extends ResponseContent
private[aws4s] case class JsonContent(json:   Json) extends ResponseContent
private[aws4s] case class StringContent(text: String) extends ResponseContent
private[aws4s] case object NoContent extends ResponseContent

private[aws4s] object ResponseContent {

  implicit def entityDecoder[F[_]: Effect]: EntityDecoder[F, ResponseContent] =
    EntityDecoder[F, scala.xml.Elem].map(elem => XmlContent(elem)).widen[ResponseContent] orElse
      EntityDecoder[F, Json].map(json         => JsonContent(json)).widen[ResponseContent] orElse
      inclusiveJsonEntityDecoder.map(json     => JsonContent(json)).widen[ResponseContent] orElse
      EntityDecoder[F, String].map(text       => StringContent(text)).widen[ResponseContent] orElse
      EntityDecoder[F, Unit].map(_            => NoContent).widen[ResponseContent]

  private def inclusiveJsonEntityDecoder[F[_]: Sync]: EntityDecoder[F, Json] = {
    val json = jsonDecoder[F]
    val extraMediaRanges = NonEmptyList.of(
      "application/x-amz-json-1.0"
    ) map (mr => MediaRange.parse(mr).getOrElse(throw new RuntimeException(s"Invalid Media Range: $mr")))
    val allMediaRanges = extraMediaRanges concat json.consumes.toList
    EntityDecoder.decodeBy[F, Json](allMediaRanges.head, allMediaRanges.tail: _*)((msg: Message[F]) => json.decode(msg, strict = false))
  }
} 

package org.aws4s.dynamodb

import cats.data.NonEmptyList
import org.aws4s.Region
import org.aws4s.core.SmokeTest

class DynamoDbSmokeTest extends SmokeTest {

  val dynamodb = DynamoDb(httpClient, Region.`us-east-1`, credentials)

  "Table creation" should "succeed" in {
    val tableName             = TableName("secret_table_fur_mich")
    val indices               = NonEmptyList.of(Index(AttributeName("name"), AttributeType.String, KeyType.Hash))
    val provisionedThroughput = ProvisionedThroughput(WriteCapacityUnits(6), ReadCapacityUnits(6))

    val action = dynamodb.createTable(tableName, indices, provisionedThroughput)

    action.attempt.unsafeToFuture().map {
      case Left(err) =>
        if (err.toString.contains("Table already exists"))
          succeed
        else
          fail(err.toString)
      case Right(cs) => cs shouldEqual CreateTableSuccess(TableDescription(tableName))
    }
  }

  "Table deletion" should "succeed" in {
    val tableName = TableName("secret_table_fur_mich")

    val action = dynamodb.deleteTable(tableName)

    action.attempt.unsafeToFuture().map {
      case Left(err) =>
        if (err.toString.contains("Attempt to change a resource which is still in use"))
          succeed
        else
          fail(err.toString)
      case Right(ds) => ds shouldEqual DeleteTableSuccess(TableDescription(tableName))
    }
  }
} 

package com.swissborg.lithium

import akka.cluster.swissborg.EitherValues
import cats.data.{NonEmptyList, NonEmptySet}
import org.scalacheck.Arbitrary
import org.scalacheck.Gen._

import scala.collection.immutable.SortedSet

package object utils extends EitherValues {

  
  def splitIn[A](parts: Int, as: NonEmptySet[A]): Arbitrary[NonEmptyList[NonEmptySet[A]]] =
    Arbitrary {
      if (parts <= 1 || parts > as.length) const(NonEmptyList.of(as))
      else {
        for {
          takeN <- chooseNum(1, as.length - parts + 1) // leave enough `as` to have at least 1 element per part
          newSet = as.toSortedSet.take(takeN.toInt)
          newSets <- splitIn(parts - 1, // parts > takeN
                             NonEmptySet.fromSetUnsafe(as.toSortedSet -- newSet)).arbitrary
        } yield NonEmptySet.fromSetUnsafe(newSet) :: newSets
      }
    }

  def pickNonEmptySubset[A: Ordering](as: NonEmptySet[A]): Arbitrary[NonEmptySet[A]] = Arbitrary {
    atLeastOne(as.toSortedSet).map(seq => NonEmptySet.fromSetUnsafe(SortedSet(seq.toSeq: _*)))
  }
} 

package io.scalaland.chimney.cats.utils

import cats.InvariantMonoidal
import cats.data.{NonEmptyChain, NonEmptyList, Validated, ValidatedNec, ValidatedNel}

object ValidatedUtils {

  implicit class OptionOps[T](val opt: Option[T]) extends AnyVal {

    def toValidated[EE[_]: InvariantMonoidal](err: => String): Validated[EE[String], T] = {
      opt match {
        case Some(value) => Validated.Valid(value)
        case None        => Validated.Invalid(InvariantMonoidal[EE].point(err))
      }
    }

    def toValidatedNec(err: => String): ValidatedNec[String, T] =
      toValidated[NonEmptyChain](err)(implicitly)

    def toValidatedNel(err: => String): ValidatedNel[String, T] =
      toValidated[NonEmptyList](err)(implicitly)
  }

  implicit class ValidatedOps[+E, +A](val validated: Validated[E, A]) extends AnyVal {

    def getValid: A = {
      validated.valueOr(_ => throw new NoSuchElementException)
    }
  }
} 

package libs.ziohelper
import cats.data.NonEmptyList
import play.api.libs.json.{JsError, JsPath, JsResult, JsSuccess, JsonValidationError}
import domains.errors.{IzanamiErrors, ValidationError}
import zio._
import libs.logs.ZLogger

object JsResults {

  def handleJsError[C <: ZLogger, T](err: Seq[(JsPath, Seq[JsonValidationError])]): ZIO[C, IzanamiErrors, T] =
    ZLogger.error(s"Error parsing json $err") *>
    IO.fail(NonEmptyList.of(ValidationError.error("error.json.parsing")))

  def jsResultToError[C <: ZLogger, T](jsResult: JsResult[T]): ZIO[C, IzanamiErrors, T] =
    fromJsResult(jsResult) { handleJsError }

  def jsResultToHttpResponse[T](jsResult: JsResult[T]) =
    liftJsResult(jsResult)(err => play.api.mvc.Results.BadRequest(ValidationError.fromJsError(err).toJson))

  def liftJsResult[T, E](jsResult: JsResult[T])(onError: Seq[(JsPath, Seq[JsonValidationError])] => E): IO[E, T] =
    jsResult match {
      case JsSuccess(value, _) => IO.succeed(value)
      case JsError(errors)     => IO.fail(onError(errors.toSeq.map(t => t.copy(_2 = t._2.toSeq))))
    }

  def fromJsResult[C <: ZLogger, T, E](
      jsResult: JsResult[T]
  )(onError: Seq[(JsPath, Seq[JsonValidationError])] => ZIO[C, E, T]): ZIO[C, E, T] =
    jsResult match {
      case JsSuccess(value, _) => ZIO.succeed(value)
      case JsError(errors)     => onError(errors.toSeq.map(t => t.copy(_2 = t._2.toSeq)))
    }

} 

package libs
import cats.data.NonEmptyList
import play.api.libs.json._
import play.api.libs.json.Reads._

object json {

  private def nelReads[A](implicit reads: Reads[A]): Reads[NonEmptyList[A]] = __.read[List[A]].flatMap {
    case h :: t => Reads.pure(NonEmptyList(h, t))
    case _ =>
      Reads[NonEmptyList[A]] { _ =>
        JsError("nonemptylist.expected")
      }
  }
  private def nelWrites[A](implicit writes: Writes[List[A]]): Writes[NonEmptyList[A]] =
    Writes[NonEmptyList[A]] { nel =>
      writes.writes(nel.toList)
    }

  implicit def nelFormat[A](implicit format: Format[A]): Format[NonEmptyList[A]] =
    Format(nelReads[A], nelWrites[A])

} 

package domains

import cats.data.NonEmptyList
import domains.errors.{IzanamiErrors, Unauthorized}
import domains.user.OauthUser
import libs.logs.ZLogger
import test.IzanamiSpec
import zio.{Layer, Runtime, ZEnv, ZLayer}
import domains.auth.AuthInfo

class AuthInfoSpec extends IzanamiSpec {

  def testLayer(admin: Boolean = false): Layer[Throwable, AuthInfo] = AuthInfo.value(
    OauthUser("1",
              "john.doe",
              "[email protected]",
              admin,
              AuthorizedPatterns(AuthorizedPattern("test", PatternRights.R)))
  )

  "AuthInfo" must {
    "is admin" in {

      val authModule: ZLayer[Any, Throwable, AuthInfo with ZLogger] = (testLayer(true) ++ ZLogger.live)

      val res: Either[IzanamiErrors, Unit] =
        Runtime.default.unsafeRun(AuthInfo.isAdmin().either.provideSomeLayer[ZEnv](authModule))
      res must be(Right(()))
    }

    "is not admin" in {
      val authModule: ZLayer[Any, Throwable, AuthInfo with ZLogger] = (testLayer() ++ ZLogger.live)

      val res: Either[IzanamiErrors, Unit] =
        Runtime.default.unsafeRun(AuthInfo.isAdmin().either.provideSomeLayer[ZEnv](authModule))
      res must be(Left(NonEmptyList.of(Unauthorized(None))))
    }
  }
} 

package de.heikoseeberger.wtat

import cats.data.{ NonEmptyList, Validated }
import cats.syntax.apply._
import cats.syntax.either._
import eu.timepit.refined.api.Refined
import eu.timepit.refined.boolean.And
import eu.timepit.refined.char.LetterOrDigit
import eu.timepit.refined.collection.{ Forall, NonEmpty }
import eu.timepit.refined.refineV

object User {

  type Username           = Refined[String, UsernameRefinement]
  type UsernameRefinement = And[NonEmpty, Forall[LetterOrDigit]]

  type Nickname           = Refined[String, NicknameRefinement]
  type NicknameRefinement = NonEmpty

  def apply(username: String, nickname: String): Validated[NonEmptyList[String], User] =
    (validateUsername(username), validateNickname(nickname)).mapN(new User(_, _))

  def validateUsername(username: String): Validated[NonEmptyList[String], Username] =
    refineV[UsernameRefinement](username).toValidatedNel

  def validateNickname(nickname: String): Validated[NonEmptyList[String], Nickname] =
    refineV[NicknameRefinement](nickname).toValidatedNel
}

final case class User(username: User.Username, nickname: User.Nickname) 

package com.landoop.streamreactor.connect.hive.sink.config

import java.util.Collections

import cats.data.NonEmptyList
import com.datamountaineer.kcql.{Field, PartitioningStrategy, SchemaEvolution}
import com.landoop.streamreactor.connect.hive._
import com.landoop.streamreactor.connect.hive.formats.{HiveFormat, ParquetHiveFormat}
import com.landoop.streamreactor.connect.hive.kerberos.Kerberos
import com.landoop.streamreactor.connect.hive.sink.evolution.{AddEvolutionPolicy, EvolutionPolicy, IgnoreEvolutionPolicy, StrictEvolutionPolicy}
import com.landoop.streamreactor.connect.hive.sink.partitioning.{DynamicPartitionHandler, PartitionHandler, StrictPartitionHandler}
import com.landoop.streamreactor.connect.hive.sink.staging._

import scala.collection.JavaConverters._

case class HiveSinkConfig(dbName: DatabaseName,
                          filenamePolicy: FilenamePolicy = DefaultFilenamePolicy,
                          stageManager: StageManager = new StageManager(DefaultFilenamePolicy),
                          tableOptions: Set[TableOptions] = Set.empty,
                          kerberos: Option[Kerberos],
                          hadoopConfiguration: HadoopConfiguration)

case class TableOptions(tableName: TableName,
                        topic: Topic,
                        createTable: Boolean = false,
                        overwriteTable: Boolean = false,
                        partitioner: PartitionHandler = new DynamicPartitionHandler(),
                        evolutionPolicy: EvolutionPolicy = IgnoreEvolutionPolicy,
                        projection: Option[NonEmptyList[Field]] = None,
                        // when creating a new table, the table will be partitioned with the fields set below
                        partitions: Seq[PartitionField] = Nil,
                        // the format used when creating a new table, if the table exists
                        // then the format will be derived from the table parameters
                        format: HiveFormat = ParquetHiveFormat,
                        commitPolicy: CommitPolicy = DefaultCommitPolicy(Some(1000 * 1000 * 128), None, None),
                        location: Option[String] = None)

object HiveSinkConfig {

  def fromProps(props: Map[String, String]): HiveSinkConfig = {

    import scala.concurrent.duration._

    val config = HiveSinkConfigDefBuilder(props.asJava)
    val tables = config.getKCQL.map { kcql =>

      val fields = Option(kcql.getFields).getOrElse(Collections.emptyList).asScala.toList
      val projection = if (fields.size == 1 && fields.head.getName == "*") None else NonEmptyList.fromList(fields)

      val flushSize = Option(kcql.getWithFlushSize).filter(_ > 0)
      val flushInterval = Option(kcql.getWithFlushInterval).filter(_ > 0).map(_.seconds)
      val flushCount = Option(kcql.getWithFlushCount).filter(_ > 0)

      // we must have at least one way of committing files
      val finalFlushSize = Some(flushSize.fold(1000L * 1000 * 128)(identity)) //if (flushSize.isEmpty ) Some(1000L * 1000 * 128) else flushSize

      val format: HiveFormat = HiveFormat(Option(kcql.getStoredAs).map(_.toLowerCase).getOrElse("parquet"))

      TableOptions(
        TableName(kcql.getTarget),
        Topic(kcql.getSource),
        kcql.isAutoCreate,
        kcql.getWithOverwrite,
        Option(kcql.getWithPartitioningStrategy).getOrElse(PartitioningStrategy.DYNAMIC) match {
          case PartitioningStrategy.DYNAMIC => new DynamicPartitionHandler()
          case PartitioningStrategy.STRICT => StrictPartitionHandler
        },
        format = format,
        projection = projection,
        evolutionPolicy = Option(kcql.getWithSchemaEvolution).getOrElse(SchemaEvolution.MATCH) match {
          case SchemaEvolution.ADD => AddEvolutionPolicy
          case SchemaEvolution.IGNORE => IgnoreEvolutionPolicy
          case SchemaEvolution.MATCH => StrictEvolutionPolicy
        },
        partitions = Option(kcql.getPartitionBy).map(_.asScala).getOrElse(Nil).map(name => PartitionField(name)).toVector,
        commitPolicy = DefaultCommitPolicy(
          fileSize = finalFlushSize,
          interval = flushInterval,
          fileCount = flushCount
        ),
        location = Option(kcql.getWithTableLocation)
      )
    }

    HiveSinkConfig(
      dbName = DatabaseName(props(SinkConfigSettings.DatabaseNameKey)),
      filenamePolicy = DefaultFilenamePolicy,
      stageManager = new StageManager(DefaultFilenamePolicy),
      tableOptions = tables,
      kerberos = Kerberos.from(config, SinkConfigSettings),
      hadoopConfiguration = HadoopConfiguration.from(config, SinkConfigSettings)
    )
  }
} 

package gospeak.core

import cats.data.NonEmptyList
import gospeak.core.GsConf.{EventConf, ProposalConf}
import gospeak.core.domain.Group
import gospeak.core.domain.messages.Message
import gospeak.libs.scala.Crypto.AesSecretKey
import gospeak.libs.scala.domain.{EmailAddress, EnumBuilder, Mustache, StringEnum}

final case class ApplicationConf(env: ApplicationConf.Env,
                                 baseUrl: String,
                                 aesKey: AesSecretKey,
                                 admins: NonEmptyList[EmailAddress]) {
  def name: String = env match {
    case ApplicationConf.Env.Local => "Gospeak Local"
    case ApplicationConf.Env.Dev => "Gospeak Dev"
    case ApplicationConf.Env.Staging => "Gospeak Staging"
    case ApplicationConf.Env.Prod => "Gospeak"
  }
}

object ApplicationConf {

  sealed trait Env extends StringEnum {
    def value: String = toString

    def isLocal: Boolean = false

    def isDev: Boolean = false

    def isStaging: Boolean = false

    def isProd: Boolean = false
  }

  object Env extends EnumBuilder[Env]("ApplicationConf.Env") {

    final case object Local extends Env {
      override def isLocal: Boolean = true
    }

    final case object Dev extends Env {
      override def isDev: Boolean = true
    }

    final case object Staging extends Env {
      override def isStaging: Boolean = true
    }

    final case object Prod extends Env {
      override def isProd: Boolean = true
    }

    val all: Seq[Env] = Seq(Local, Dev, Staging, Prod)
  }

}

final case class GsConf(event: EventConf, proposal: ProposalConf) {
  def defaultGroupSettings: Group.Settings = Group.Settings(
    accounts = Group.Settings.Accounts(
      meetup = None,
      slack = None),
    // twitter = None,
    // youtube = None),
    event = Group.Settings.Event(
      description = event.description,
      templates = Map()),
    proposal = Group.Settings.Proposal(
      tweet = proposal.tweet),
    actions = Map())
}

object GsConf {

  final case class EventConf(description: Mustache.Markdown[Message.EventInfo])

  final case class ProposalConf(tweet: Mustache.Text[Message.ProposalInfo])

} 

package gospeak.core.domain.messages

import cats.data.NonEmptyList
import gospeak.core.domain.Group
import gospeak.core.domain.utils.SocialAccounts
import gospeak.libs.scala.domain._

final case class MsgGroup(slug: Group.Slug,
                          name: Group.Name,
                          logo: Option[Logo],
                          banner: Option[Banner],
                          contact: Option[EmailAddress],
                          website: Option[Url],
                          description: Markdown,
                          links: SocialAccounts,
                          tags: Seq[Tag],
                          orgas: NonEmptyList[MsgUser.Embed],
                          sponsors: Seq[MsgSponsor.Embed],
                          publicLink: String,
                          orgaLink: String) 

package gospeak.core.domain.messages

import cats.data.NonEmptyList
import gospeak.core.domain.{Proposal, Talk, User}
import gospeak.libs.scala.Extensions._
import gospeak.libs.scala.domain._

import scala.concurrent.duration._

final case class MsgProposal(id: Proposal.Id,
                             title: Talk.Title,
                             duration: FiniteDuration,
                             description: Markdown,
                             speakers: NonEmptyList[MsgUser.Embed],
                             slides: Option[Url.Slides],
                             video: Option[Url.Video],
                             tags: Seq[Tag],
                             publicLink: String,
                             orgaLink: String)

object MsgProposal {

  final case class Embed(id: Proposal.Id,
                         title: Talk.Title,
                         duration: FiniteDuration,
                         description: Markdown,
                         speakers: NonEmptyList[MsgUser.Embed],
                         slides: Option[Url.Slides],
                         video: Option[Url.Video],
                         tags: Seq[Tag],
                         publicLink: String,
                         orgaLink: String)

  object Embed {
    def unknown(id: Proposal.Id): Embed = Embed(
      id = id,
      title = Talk.Title("Unknown talk"),
      duration = 0.minute,
      description = Markdown(""),
      speakers = NonEmptyList.of(MsgUser.Embed.unknown(User.Id.from("00000000-0000-0000-0000-000000000000").get)),
      slides = None,
      video = None,
      tags = Seq(),
      publicLink = "",
      orgaLink = "")
  }

} 

package gospeak.core.domain

import cats.data.NonEmptyList
import gospeak.core.domain.utils._
import gospeak.libs.scala.domain._

import scala.concurrent.duration.FiniteDuration

final case class Talk(id: Talk.Id,
                      slug: Talk.Slug,
                      status: Talk.Status,
                      title: Talk.Title,
                      duration: FiniteDuration,
                      description: Markdown,
                      message: Markdown,
                      speakers: NonEmptyList[User.Id],
                      slides: Option[Url.Slides],
                      video: Option[Url.Video],
                      tags: Seq[Tag],
                      info: Info) {
  def data: Talk.Data = Talk.Data(this)

  def hasSpeaker(user: User.Id): Boolean = speakers.toList.contains(user)

  def speakerUsers(users: Seq[User]): List[User] = speakers.toList.flatMap(id => users.find(_.id == id))

  def users: List[User.Id] = (speakers.toList ++ info.users).distinct
}

object Talk {
  def apply(d: Data,
            status: Status,
            speakers: NonEmptyList[User.Id],
            info: Info): Talk =
    new Talk(Id.generate(), d.slug, status, d.title, d.duration, d.description, d.message, speakers, d.slides, d.video, d.tags, info)

  final class Id private(value: String) extends DataClass(value) with IId

  object Id extends UuidIdBuilder[Id]("Talk.Id", new Id(_))

  final class Slug private(value: String) extends DataClass(value) with ISlug

  object Slug extends SlugBuilder[Slug]("Talk.Slug", new Slug(_))

  final case class Title(value: String) extends AnyVal

  sealed trait Status extends StringEnum {
    def value: String = toString
  }

  object Status extends EnumBuilder[Status]("Talk.Status") {

    case object Public extends Status {
      def description = s"Talk on your speaker public page. Organizers can contact you to perform it."
    }

    case object Private extends Status {
      def description = "Only you can see it, you can propose it to groups but organizers can't search for it."
    }

    case object Archived extends Status {
      def description = "When your talk is not actual anymore. Will be hidden everywhere."
    }

    val all: Seq[Status] = Seq(Public, Private, Archived)
    val current: NonEmptyList[Status] = NonEmptyList.of(Public, Private)
  }

  final case class Data(slug: Talk.Slug,
                        title: Talk.Title,
                        duration: FiniteDuration,
                        description: Markdown,
                        message: Markdown,
                        slides: Option[Url.Slides],
                        video: Option[Url.Video],
                        tags: Seq[Tag])

  object Data {
    def apply(t: Talk): Data = Data(t.slug, t.title, t.duration, t.description, t.message, t.slides, t.video, t.tags)
  }

} 

package org.scalacheck.cats.laws


import cats.laws.discipline._
import cats.kernel.laws.discipline._
import cats.data.NonEmptyList
import cats.tests.CatsSuite
import org.scalacheck.Gen
import org.scalacheck.cats.ScalaCheckSetup
import org.scalacheck.cats.instances.GenInstances._

class GenLaws extends CatsSuite with ScalaCheckSetup {
  // Tests Alternative
  checkAll("Gen", AlternativeTests[Gen].alternative[Int, Int, Int])
  // Tests Monad
  checkAll("Gen", MonadTests[Gen].monad[Int, Int, Int])
  // Tests FunctorFilter
  checkAll("Gen.FunctorFilterLaws", FunctorFilterTests[Gen].functorFilter[Int, Int, Int])

  // Tests Monoid for Inner Given Monoid
  checkAll("Gen[String]", MonoidTests[Gen[String]].monoid)
  // Tests Low Priority Semigroup
  checkAll("Gen[NonEmptyList[Int]]", SemigroupTests[Gen[NonEmptyList[Int]]].semigroup)
} 

package com.mesosphere.cosmos.finch

import cats.data.NonEmptyList
import com.mesosphere.http.CompoundMediaType
import com.mesosphere.http.MediaType
import io.circe.Encoder
import io.circe.Json
import io.circe.syntax._
import org.scalatest.FreeSpec

final class DispatchingMediaTypedEncoderSpec extends FreeSpec {

  import DispatchingMediaTypedEncoderSpec._

  "encoderFor(MediaType) should" - {

    "return the first encoder with a media type compatible with the argument" in {
      val Some(mediaTypedEncoder) = ThreeElementEncoder(CompoundMediaType(MediaType("foo", "bar")))
      assertResult(Json.fromInt(1))(mediaTypedEncoder.encoder(()))
      assertResult(NonEmptyList.of(MediaType("foo", "bar")))(mediaTypedEncoder.mediaTypes)
    }

    "indicate failure if no compatible encoder is found" - {

      "because there are no encoders" in {
        val dispatchingEncoder = DispatchingMediaTypedEncoder(Set.empty[MediaTypedEncoder[String]])
        assertResult(None)(dispatchingEncoder(CompoundMediaType(TestingMediaTypes.applicationJson)))
      }

      "because there are only incompatible encoders" in {
        assertResult(None)(ThreeElementEncoder(CompoundMediaType(TestingMediaTypes.applicationJson)))
      }

    }

  }

  "mediaTypes should return the media types of each of the encoders" - {
    "zero elements" in {
      assertResult(Set.empty)(DispatchingMediaTypedEncoder(Set.empty[MediaTypedEncoder[String]]).mediaTypes)
    }

    "three elements" in {
      val expected = Set(MediaType("foo", "foo"), MediaType("foo", "bar"), MediaType("foo", "baz"))
      assertResult(expected)(ThreeElementEncoder.mediaTypes)
    }
  }

}

object DispatchingMediaTypedEncoderSpec {

  val ThreeElementEncoder: DispatchingMediaTypedEncoder[Unit] = DispatchingMediaTypedEncoder(Set(
    MediaTypedEncoder(Encoder.instance[Unit](_ => 0.asJson), MediaType("foo", "foo")),
    MediaTypedEncoder(Encoder.instance[Unit](_ => 1.asJson), MediaType("foo", "bar")),
    MediaTypedEncoder(Encoder.instance[Unit](_ => 2.asJson), MediaType("foo", "baz"))
  ))

} 

package com.mesosphere.cosmos.finch

import cats.data.NonEmptyList
import com.mesosphere.http.MediaType
import io.circe.Encoder
import io.circe.Json


trait MediaTypedEncoder[A] {
  /// Describes the JSON encoder associated with this type.
  val encoder: Encoder[A]

  /// Enumerate all of the possible media types for this type.
  val mediaTypes: NonEmptyList[MediaType]

  /// Returns the specific media type based on the value of the type.
  def mediaType(a: A): MediaType

  def apply(a: A): (Json, MediaType) = (encoder(a), mediaType(a))
}

final class SimpleMediaTypedEncoder[A](
  val encoder: Encoder[A],
  mediaTypeForA: MediaType
) extends MediaTypedEncoder[A] {
  val mediaTypes = NonEmptyList.of(mediaTypeForA)
  def mediaType(a: A): MediaType = mediaTypeForA
}

object MediaTypedEncoder {

  def apply[A](mediaType: MediaType)(implicit encoder: Encoder[A]): MediaTypedEncoder[A] = {
    MediaTypedEncoder(encoder, mediaType)
  }

  def apply[A](encoder: Encoder[A], mediaType: MediaType): MediaTypedEncoder[A] = {
    new SimpleMediaTypedEncoder(encoder, mediaType)
  }

} 

package com.mesosphere.cosmos.finch

import cats.data.NonEmptyList
import com.mesosphere.cosmos.circe.Decoders.convertToCosmosError
import com.mesosphere.cosmos.error.UnsupportedContentType
import com.mesosphere.error.Result
import com.mesosphere.http.MediaType
import io.circe.Decoder
import io.circe.HCursor
import scala.reflect.ClassTag


trait MediaTypedDecoder[A] {
  val mediaTypes: NonEmptyList[MediaType]
  val decoder: Decoder[A]

  def apply(cursor: HCursor, mediaType: MediaType): Result[A]
}

final class SimpleMediaTypedDecoder[A](
  val mediaTypes: NonEmptyList[MediaType],
  val decoder: Decoder[A]
)(
  implicit classTag: ClassTag[A]
) extends MediaTypedDecoder[A] {

  def apply(cursor: HCursor, mediaType: MediaType): Result[A] = {
    if (mediaTypes.exists(current => MediaType.compatible(current, mediaType))) {
      convertToCosmosError(decoder(cursor), cursor.value.noSpaces)
    } else {
      Left(
        UnsupportedContentType(
          mediaTypes.toList,
          Some(mediaType.show)
        )
      )
    }
  }
}

object MediaTypedDecoder {
  def apply[A](
    mediaTypes: NonEmptyList[MediaType]
  )(
    implicit decoder: Decoder[A],
    classTag: ClassTag[A]
  ): MediaTypedDecoder[A] = {
    new SimpleMediaTypedDecoder(mediaTypes, decoder)
  }

  def apply[A](
    mediaType: MediaType
  )(
    implicit decoder: Decoder[A],
    classTag: ClassTag[A]
  ): MediaTypedDecoder[A] = {
    MediaTypedDecoder(NonEmptyList.of(mediaType))
  }

} 

package io.github.pauljamescleary.petstore
package infrastructure.repository.inmemory

import scala.collection.concurrent.TrieMap
import scala.util.Random

import cats._
import cats.data.NonEmptyList
import cats.implicits._
import domain.pets.{Pet, PetRepositoryAlgebra, PetStatus}

class PetRepositoryInMemoryInterpreter[F[_]: Applicative] extends PetRepositoryAlgebra[F] {
  private val cache = new TrieMap[Long, Pet]

  private val random = new Random

  def create(pet: Pet): F[Pet] = {
    val id = random.nextLong
    val toSave = pet.copy(id = id.some)
    cache += (id -> pet.copy(id = id.some))
    toSave.pure[F]
  }

  def update(pet: Pet): F[Option[Pet]] = pet.id.traverse { id =>
    cache.update(id, pet)
    pet.pure[F]
  }

  def get(id: Long): F[Option[Pet]] = cache.get(id).pure[F]

  def delete(id: Long): F[Option[Pet]] = cache.remove(id).pure[F]

  def findByNameAndCategory(name: String, category: String): F[Set[Pet]] =
    cache.values
      .filter(p => p.name == name && p.category == category)
      .toSet
      .pure[F]

  def list(pageSize: Int, offset: Int): F[List[Pet]] =
    cache.values.toList.sortBy(_.name).slice(offset, offset + pageSize).pure[F]

  def findByStatus(statuses: NonEmptyList[PetStatus]): F[List[Pet]] =
    cache.values.filter(p => statuses.exists(_ == p.status)).toList.pure[F]

  def findByTag(tags: NonEmptyList[String]): F[List[Pet]] = {
    val tagSet = tags.toNes
    cache.values.filter(_.tags.exists(tagSet.contains(_))).toList.pure[F]
  }
}

object PetRepositoryInMemoryInterpreter {
  def apply[F[_]: Applicative]() = new PetRepositoryInMemoryInterpreter[F]()
} 

package io.github.pauljamescleary.petstore
package infrastructure.repository.doobie

import cats.data.NonEmptyList
import cats.effect.IO
import cats.syntax.applicative._
import doobie.scalatest.IOChecker
import doobie.util.transactor.Transactor
import org.scalatest.funsuite.AnyFunSuite
import PetStoreArbitraries.pet
import org.scalatest.matchers.should.Matchers

class PetQueryTypeCheckSpec extends AnyFunSuite with Matchers with IOChecker {
  override val transactor: Transactor[IO] = testTransactor

  import PetSQL._

  test("Typecheck pet queries") {
    pet.arbitrary.sample.map { p =>
      check(selectByStatus(p.status.pure[NonEmptyList]))
      check(insert(p))
      p.id.foreach(id => check(PetSQL.update(p, id)))
    }

    check(selectTagLikeString("example".pure[NonEmptyList]))
    check(select(1L))
    check(selectAll)
    check(delete(1L))
    check(selectByNameAndCategory("name", "category"))
  }
} 

package io.protoless.tests.samples

import cats.data.NonEmptyList
import io.protoless.tag._

case class TestCaseCollections(
  d: Seq[Double],
  f: List[Float],
  i: collection.immutable.Seq[Int],
  l: Array[Long],
  ui: scala.collection.Traversable[Int @@ Unsigned],
  ul: scala.collection.Iterable[Long @@ Unsigned],
  si: Stream[Int @@ Signed],
  sl: Vector[Long @@ Signed],
  fi: NonEmptyList[Int @@ Fixed]
)

object TestCaseCollections extends TestCase[TestCaseCollections] {

  override val source: TestCaseCollections = TestCaseCollections(
    d = Seq(1d, 2d),
    f = List(1f, 2f),
    i = scala.collection.immutable.Seq(1, 2),
    l = Array(1L, 2L),
    ui = Seq(unsigned(1), unsigned(2)),
    ul = Seq(unsigned(1L), unsigned(2L)),
    si = Seq(signed(1), signed(2)).toStream,
    sl = Seq(signed(1L), signed(2L)).toVector,
    fi = NonEmptyList.of(fixed(Int.MaxValue))
  )

  override val protobuf: ProtoSerializable = ProtoSerializable(Schemas.Repeated.newBuilder()
    .addDoubleField(source.d(0)).addDoubleField(source.d(1))
    .addFloatField(source.f(0)).addFloatField(source.f(1))
    .addInt32Field(source.i(0)).addInt32Field(source.i(1))
    .addInt64Field(source.l(0)).addInt64Field(source.l(1))
    .addUint32Field(source.ui.toList(0)).addUint32Field(source.ui.toList(1))
    .addUint64Field(source.ul.toList(0)).addUint64Field(source.ul.toList(1))
    .addSint32Field(source.si(0)).addSint32Field(source.si(1))
    .addSint64Field(source.sl(0)).addSint64Field(source.sl(1))
    .addFixed32Field(source.fi.head)
    .build())
} 

package com.twilio.guardrail
package sbt

import _root_.sbt.{FeedbackProvidedException, WatchSource}
import cats.data.NonEmptyList
import cats.implicits._
import cats.~>
import com.twilio.guardrail.{Args => ArgsImpl}
import scala.io.AnsiColor
import scala.meta._
import _root_.io.swagger.parser.SwaggerParserExtension

class CodegenFailedException extends FeedbackProvidedException

object Tasks {
  def guardrailTask(
    runner: Map[String,cats.data.NonEmptyList[com.twilio.guardrail.Args]] => com.twilio.guardrail.Target[List[java.nio.file.Path]]
  )(tasks: List[Types.Args], sourceDir: java.io.File): Seq[java.io.File] = {
    // swagger-parser uses SPI to find extensions on the classpath (by default, only the OAPI2 -> OAPI3 converter)
    // See https://github.com/swagger-api/swagger-parser#extensions
    // That being said, Scala's classloader seems to have some issues finding SPI resources:
    // - https://github.com/scala/bug/issues/10247
    // - https://github.com/meetup/sbt-openapi/blob/363fa14/src/main/scala/com/meetup/sbtopenapi/Plugin.scala#L64-L71
    // As a result, we temporarily overwrite Scala's classloader to whichever one loaded swagger-parser, in the hopes
    // that it'll pick up the rest of the SPI classes.
    val oldClassLoader = Thread.currentThread().getContextClassLoader()
    Thread.currentThread().setContextClassLoader(classOf[SwaggerParserExtension].getClassLoader)

    val preppedTasks: Map[String, NonEmptyList[ArgsImpl]] = tasks.foldLeft(Map.empty[String, NonEmptyList[ArgsImpl]]) { case (acc, (language, args)) =>
      val prepped = args.copy(outputPath=Some(sourceDir.getPath))
      acc.updated(language, acc.get(language).fold(NonEmptyList.one(prepped))(_ :+ prepped))
    }

    val  =
      runner
        .apply(preppedTasks)
        .fold[List[java.nio.file.Path]]({
          case MissingArg(args, Error.ArgName(arg)) =>
            println(s"${AnsiColor.RED}Missing argument:${AnsiColor.RESET} ${AnsiColor.BOLD}${arg}${AnsiColor.RESET} (In block ${args})")
            throw new CodegenFailedException()
          case NoArgsSpecified =>
            List.empty
          case NoFramework =>
            println(s"${AnsiColor.RED}No framework specified${AnsiColor.RESET}")
            throw new CodegenFailedException()
          case PrintHelp =>
            List.empty
          case UnknownArguments(args) =>
            println(s"${AnsiColor.RED}Unknown arguments: ${args.mkString(" ")}${AnsiColor.RESET}")
            throw new CodegenFailedException()
          case UnparseableArgument(name, message) =>
            println(s"${AnsiColor.RED}Unparseable argument ${name}: ${message}${AnsiColor.RESET}")
            throw new CodegenFailedException()
          case UnknownFramework(name) =>
            println(s"${AnsiColor.RED}Unknown framework specified: ${name}${AnsiColor.RESET}")
            throw new CodegenFailedException()
          case RuntimeFailure(message) =>
            println(s"${AnsiColor.RED}Error:${AnsiColor.RESET}${message}")
            throw new CodegenFailedException()
          case UserError(message) =>
            println(s"${AnsiColor.RED}Error:${AnsiColor.RESET}${message}")
            throw new CodegenFailedException()
          case MissingModule(section) =>
            println(s"${AnsiColor.RED}Error: Missing module ${section}${AnsiColor.RESET}")
            throw new CodegenFailedException()
          case ModuleConflict(section) =>
            println(s"${AnsiColor.RED}Error: Too many modules specified for ${section}${AnsiColor.RESET}")
            throw new CodegenFailedException()
          case UnconsumedModules(modules) =>
            println(s"${AnsiColor.RED}Error: Unconsumed modules: ${modules.mkString(", ")}${AnsiColor.RESET}")
            throw new CodegenFailedException()
        }, identity)
        //.runEmpty

    Thread.currentThread().setContextClassLoader(oldClassLoader)
    paths.map(_.toFile).distinct
  }

  def watchSources(tasks: List[Types.Args]): Seq[WatchSource] = {
    tasks.flatMap(_._2.specPath.map(new java.io.File(_)).map(WatchSource(_))).toSeq
  }
} 

package com.landoop.streamreactor.connect.hive

import cats.Show
import cats.data.NonEmptyList
import org.apache.hadoop.fs.Path
import org.apache.kafka.common.{TopicPartition => KafkaTopicPartition}
import org.apache.kafka.connect.data.Schema

case class Topic(value: String) {
  require(value != null && value.trim.nonEmpty)
}

case class Offset(value: Long) {
  require(value >= 0)
}

case class TopicPartition(topic: Topic, partition: Int) {
  def withOffset(offset: Offset): TopicPartitionOffset = TopicPartitionOffset(topic, partition, offset)
  def toKafka = new KafkaTopicPartition(topic.value, partition)
}

case class TopicPartitionOffset(topic: Topic, partition: Int, offset: Offset) {
  def toTopicPartition = TopicPartition(topic, partition)
}

case class DatabaseName(value: String) {
  require(value != null && value.trim.nonEmpty)
}

case class TableName(value: String) {
  require(value != null && value.trim.nonEmpty)
}

// contains all the partition keys for a particular table
case class PartitionPlan(tableName: TableName, keys: NonEmptyList[PartitionKey])

// contains a partition key, which you can think of as like a partition column name
case class PartitionKey(value: String)

// defines a partition key field
case class PartitionField(name: String, schema: Schema = Schema.STRING_SCHEMA, comment: Option[String] = None) {
  require(name != null && name.trim.nonEmpty)
}

// contains a single partition in a table, that is one set of unique values, one per partition key
case class Partition(entries: NonEmptyList[(PartitionKey, String)], location: Option[Path])

case class Serde(serializationLib: String, inputFormat: String, outputFormat: String, params: Map[String, String])

// generates the default hive metatstore location string for a partition
object DefaultPartitionLocation extends Show[Partition] {
  override def show(t: Partition): String = {
    t.entries.map { case (key, value) => key.value + "=" + value }.toList.mkString("/")
  }
} 

package gospeak.libs.openapi

import cats.data.NonEmptyList
import gospeak.libs.scala.Extensions._
import gospeak.libs.openapi.JsonUtils._
import gospeak.libs.openapi.error.OpenApiError.ErrorMessage
import gospeak.libs.openapi.error.{OpenApiError, OpenApiErrors}
import gospeak.libs.openapi.models._
import gospeak.libs.openapi.models.utils._
import play.api.libs.json._

object OpenApiFactory {
  def parseJson(json: JsValue): Either[OpenApiErrors, OpenApi] = {
    import Formats._
    json.validate[OpenApi].fold(
      errors => Left(OpenApiErrors(errors.map(formatError))),
      openApi => Right(openApi)
    )
  }

  def toJson(openApi: OpenApi): JsValue = {
    import Formats._
    Json.toJson(openApi)
  }

  object Formats {
    // `lazy` is useful for recursive types: the sub-type needs the super-type but it's not defined yet. If not lazy, you got a NullPointerException
    private val fString: Format[String] = Format((json: JsValue) => json.validate[String], (o: String) => JsString(o))
    implicit lazy val fTODO: Format[TODO] = Format((_: JsValue) => JsSuccess(TODO()), (_: TODO) => JsNull)
    implicit lazy val fMarkdown: Format[Markdown] = fString.imap(Markdown)(_.value)
    implicit lazy val fUrl: Format[Url] = fString.validate(Url.from)(_.value)
    implicit lazy val fEmail: Format[Email] = fString.validate(Email.from)(_.value)
    implicit lazy val fVersion: Format[Version] = fString.validate(Version.from)(_.format)
    implicit lazy val fJs: Format[Js] = Format(js => JsSuccess(Js(js.toString, js.getClass.getSimpleName)), a => Json.parse(a.value))

    implicit lazy val fReference: Format[Reference] = fString.validate(Reference.from)(_.value)
    implicit lazy val fInfoContact: Format[Info.Contact] = Json.format[Info.Contact]
    implicit lazy val fInfoLicense: Format[Info.License] = Json.format[Info.License]
    implicit lazy val fInfo: Format[Info] = Json.format[Info]
    implicit lazy val fExternalDoc: Format[ExternalDoc] = Json.format[ExternalDoc]
    implicit lazy val fServerVariable: Format[Server.Variable] = Json.format[Server.Variable]
    implicit lazy val fServer: Format[Server] = Json.format[Server]
    implicit lazy val fTag: Format[Tag] = Json.format[Tag]
    implicit lazy val fSchemaString: Format[Schema.StringVal] = Json.format[Schema.StringVal].hint(Schema.hintAttr, Schema.StringVal.hint)
    implicit lazy val fSchemaInteger: Format[Schema.IntegerVal] = Json.format[Schema.IntegerVal].hint(Schema.hintAttr, Schema.IntegerVal.hint)
    implicit lazy val fSchemaNumber: Format[Schema.NumberVal] = Json.format[Schema.NumberVal].hint(Schema.hintAttr, Schema.NumberVal.hint)
    implicit lazy val fSchemaBoolean: Format[Schema.BooleanVal] = Json.format[Schema.BooleanVal].hint(Schema.hintAttr, Schema.BooleanVal.hint)
    implicit lazy val fSchemaArray: Format[Schema.ArrayVal] = Json.format[Schema.ArrayVal].hint(Schema.hintAttr, Schema.ArrayVal.hint)
    implicit lazy val fSchemaObject: Format[Schema.ObjectVal] = Json.format[Schema.ObjectVal].hint(Schema.hintAttr, Schema.ObjectVal.hint)
    implicit lazy val fSchemaReference: Format[Schema.ReferenceVal] = Json.format[Schema.ReferenceVal]
    implicit lazy val fSchemaCombination: Format[Schema.CombinationVal] = Json.format[Schema.CombinationVal]
    implicit lazy val fSchema: Format[Schema] = Format[Schema](
      (json: JsValue) => (json \ Schema.hintAttr).asOpt[String] match {
        case Some(Schema.StringVal.hint) => fSchemaString.reads(json)
        case Some(Schema.IntegerVal.hint) => fSchemaInteger.reads(json)
        case Some(Schema.NumberVal.hint) => fSchemaNumber.reads(json)
        case Some(Schema.BooleanVal.hint) => fSchemaBoolean.reads(json)
        case Some(Schema.ArrayVal.hint) => fSchemaArray.reads(json)
        case Some(Schema.ObjectVal.hint) => fSchemaObject.reads(json)
        case Some(value) => JsError(Seq(OpenApiError.unknownHint(value, Schema.hintAttr).atPath(Schema.hintAttr).toJson))
        case None if (json \ Schema.ReferenceVal.hintAttr).asOpt[String].isDefined => fSchemaReference.reads(json)
        case None => fSchemaCombination.reads(json)
      },
      {
        case s: Schema.StringVal => fSchemaString.writes(s)
        case s: Schema.IntegerVal => fSchemaInteger.writes(s)
        case s: Schema.NumberVal => fSchemaNumber.writes(s)
        case s: Schema.BooleanVal => fSchemaBoolean.writes(s)
        case s: Schema.ArrayVal => fSchemaArray.writes(s)
        case s: Schema.ObjectVal => fSchemaObject.writes(s)
        case s: Schema.ReferenceVal => fSchemaReference.writes(s)
        case s: Schema.CombinationVal => fSchemaCombination.writes(s)
      })
    implicit lazy val fSchemas: Format[Schemas] = implicitly[Format[Map[String, Schema]]].imap(Schemas(_))(_.value)
    implicit lazy val fParameterLocation: Format[Parameter.Location] = fString.validate(Parameter.Location.from)(_.value)
    implicit lazy val fParameter: Format[Parameter] = Json.format[Parameter]
    implicit lazy val fComponents: Format[Components] = Json.format[Components]
    implicit lazy val fHeader: Format[Header] = Json.format[Header]
    implicit lazy val fMediaType: Format[MediaType] = Json.format[MediaType]
    implicit lazy val fLink: Format[Link] = Json.format[Link]
    implicit lazy val fResponse: Format[Response] = Json.format[Response]
    implicit lazy val fRequestBody: Format[RequestBody] = Json.format[RequestBody]
    implicit lazy val fPathItemOperation: Format[PathItem.Operation] = Json.format[PathItem.Operation]
    implicit lazy val fPathItem: Format[PathItem] = Json.format[PathItem]
    implicit lazy val fPaths: Format[Map[Path, PathItem]] = implicitly[Format[Map[String, PathItem]]].validate(
      _.map { case (k, v) => Path.from(k).map(p => (p, v)) }.sequence.map(_.toMap))(
      _.map { case (k, v) => (k.value, v) })
    implicit lazy val fOpenApi: Format[OpenApi] = Json.format[OpenApi].verify(_.getErrors)
  }

  private def formatError(errs: (JsPath, Seq[JsonValidationError])): OpenApiError =
    OpenApiError(
      path = errs._1.path.map(_.toJsonString),
      errors = errs._2.map(err => ErrorMessage(err.message, err.args.map(_.toString).toList)).toNel.getOrElse(NonEmptyList.of(ErrorMessage.noMessage())))

} 

package com.landoop.streamreactor.connect.hive.sink.mapper

import cats.data.NonEmptyList
import com.datamountaineer.kcql.Field
import com.landoop.streamreactor.connect.hive.StructMapper
import org.apache.kafka.connect.data.{SchemaBuilder, Struct}


class ProjectionMapper(projection: NonEmptyList[Field]) extends StructMapper {

  override def map(input: Struct): Struct = {
    // the compatible output schema built from projected fields with aliases applied
    val builder = projection.foldLeft(SchemaBuilder.struct) { (builder, kcqlField) =>
      Option(input.schema.field(kcqlField.getName)).fold(sys.error(s"Missing field $kcqlField")) { field =>
        builder.field(kcqlField.getAlias, field.schema)
      }
    }
    val schema = builder.build()
    projection.foldLeft(new Struct(schema)) { (struct, field) =>
      struct.put(field.getAlias, input.get(field.getName))
    }
  }
} 

package com.landoop.streamreactor.connect.hive.source.config

import java.util.Collections

import cats.data.NonEmptyList
import com.landoop.streamreactor.connect.hive.{DatabaseName, HadoopConfiguration, TableName, Topic}
import com.landoop.streamreactor.connect.hive.kerberos.Kerberos

import scala.collection.JavaConverters._

case class ProjectionField(name: String, alias: String)

case class HiveSourceConfig(dbName: DatabaseName,
                            kerberos: Option[Kerberos],
                            hadoopConfiguration: HadoopConfiguration,
                            tableOptions: Set[SourceTableOptions] = Set.empty,
                            pollSize: Int = 1024)

case class SourceTableOptions(
  tableName: TableName,
  topic: Topic,
  projection: Option[NonEmptyList[ProjectionField]] = None,
  limit: Int = Int.MaxValue
)

object HiveSourceConfig {

  def fromProps(props: Map[String, String]): HiveSourceConfig = {

    val config = HiveSourceConfigDefBuilder(props.asJava)
    val tables = config.getKCQL.map { kcql =>
      val fields = Option(kcql.getFields)
        .getOrElse(Collections.emptyList)
        .asScala
        .toList
        .map { field =>
          ProjectionField(field.getName, field.getAlias)
        }

      val projection = fields match {
        case Nil                              => None
        case ProjectionField("*", "*") :: Nil => None
        case _                                => NonEmptyList.fromList(fields)
      }

      SourceTableOptions(
        TableName(kcql.getSource),
        Topic(kcql.getTarget),
        projection,
        limit = if (kcql.getLimit < 1) Int.MaxValue else kcql.getLimit
      )
    }

    HiveSourceConfig(
      dbName = DatabaseName(props(HiveSourceConfigConstants.DatabaseNameKey)),
      tableOptions = tables,
      kerberos = Kerberos.from(config, HiveSourceConfigConstants),
      hadoopConfiguration =
        HadoopConfiguration.from(config, HiveSourceConfigConstants),
      pollSize = props
        .getOrElse(HiveSourceConfigConstants.PollSizeKey, 1024)
        .toString
        .toInt
    )
  }
} 

package com.landoop.streamreactor.connect.hive.source.mapper

import cats.data.NonEmptyList
import com.landoop.streamreactor.connect.hive.StructMapper
import com.landoop.streamreactor.connect.hive.source.config.ProjectionField
import org.apache.kafka.connect.data.{SchemaBuilder, Struct}

class ProjectionMapper(projection: NonEmptyList[ProjectionField]) extends StructMapper {

  override def map(input: Struct): Struct = {
    val builder = projection.foldLeft(SchemaBuilder.struct) { (builder, projectionField) =>
      Option(input.schema.field(projectionField.name))
        .fold(sys.error(s"Projection field ${projectionField.name} cannot be found in input")) { field =>
          builder.field(projectionField.alias, field.schema)
        }
    }
    val schema = builder.build()
    projection.foldLeft(new Struct(schema)) { (struct, field) =>
      struct.put(field.alias, input.get(field.name))
    }
  }
} 

package com.landoop.streamreactor.connect.hive.sink.mapper

import cats.data.NonEmptyList
import com.landoop.streamreactor.connect.hive.{PartitionKey, PartitionPlan, TableName}
import org.apache.kafka.connect.data.{SchemaBuilder, Struct}
import org.scalatest.funsuite.AnyFunSuite
import org.scalatest.matchers.should.Matchers

import scala.collection.JavaConverters._

class DropPartitionValuesMapperTest extends AnyFunSuite with Matchers {

  test("strip partition values") {

    val schema = SchemaBuilder.struct()
      .field("a", SchemaBuilder.string().required().build())
      .field("p", SchemaBuilder.string().required().build())
      .field("q", SchemaBuilder.string().required().build())
      .field("z", SchemaBuilder.string().required().build())
      .build()

    val plan = PartitionPlan(TableName("foo"), NonEmptyList.of(PartitionKey("p"), PartitionKey("q")))
    val struct = new Struct(schema).put("a", "a").put("p", "p").put("q", "q").put("z", "z")
    val output = new DropPartitionValuesMapper(plan).map(struct)
    output.schema().fields().asScala.map(_.name) shouldBe Seq("a", "z")
  }

  test("handle partition field is missing in input") {

    val schema = SchemaBuilder.struct()
      .field("a", SchemaBuilder.string().required().build())
      .field("q", SchemaBuilder.string().required().build())
      .field("z", SchemaBuilder.string().required().build())
      .build()


    val plan = PartitionPlan(TableName("foo"), NonEmptyList.of(PartitionKey("p"), PartitionKey("q")))
    val struct = new Struct(schema).put("a", "a").put("q", "q").put("z", "z")
    val output = new DropPartitionValuesMapper(plan).map(struct)
    output.schema().fields().asScala.map(_.name) shouldBe Seq("a", "z")
  }
} 

package com.landoop.streamreactor.connect.hive

import cats.Show
import cats.data.NonEmptyList
import org.apache.hadoop.fs.Path
import org.apache.kafka.common.{TopicPartition => KafkaTopicPartition}
import org.apache.kafka.connect.data.Schema

case class Topic(value: String) {
  require(value != null && value.trim.nonEmpty)
}

case class Offset(value: Long) {
  require(value >= 0)
}

case class TopicPartition(topic: Topic, partition: Int) {
  def withOffset(offset: Offset): TopicPartitionOffset = TopicPartitionOffset(topic, partition, offset)
  def toKafka = new KafkaTopicPartition(topic.value, partition)
}

case class TopicPartitionOffset(topic: Topic, partition: Int, offset: Offset) {
  def toTopicPartition = TopicPartition(topic, partition)
}

case class DatabaseName(value: String) {
  require(value != null && value.trim.nonEmpty)
}

case class TableName(value: String) {
  require(value != null && value.trim.nonEmpty)
}

// contains all the partition keys for a particular table
case class PartitionPlan(tableName: TableName, keys: NonEmptyList[PartitionKey])

// contains a partition key, which you can think of as like a partition column name
case class PartitionKey(value: String)

// defines a partition key field
case class PartitionField(name: String, schema: Schema = Schema.STRING_SCHEMA, comment: Option[String] = None) {
  require(name != null && name.trim.nonEmpty)
}

// contains a single partition in a table, that is one set of unique values, one per partition key
case class Partition(entries: NonEmptyList[(PartitionKey, String)], location: Option[Path])

case class Serde(serializationLib: String, inputFormat: String, outputFormat: String, params: Map[String, String])

// generates the default hive metatstore location string for a partition
object DefaultPartitionLocation extends Show[Partition] {
  override def show(t: Partition): String = {
    t.entries.map { case (key, value) => key.value + "=" + value }.toList.mkString("/")
  }
} 

package com.landoop.streamreactor.connect.hive.sink.config

import java.util.Collections

import cats.data.NonEmptyList
import com.datamountaineer.kcql.{Field, PartitioningStrategy, SchemaEvolution}
import com.landoop.streamreactor.connect.hive._
import com.landoop.streamreactor.connect.hive.formats.{HiveFormat, ParquetHiveFormat}
import com.landoop.streamreactor.connect.hive.kerberos.Kerberos
import com.landoop.streamreactor.connect.hive.sink.evolution.{AddEvolutionPolicy, EvolutionPolicy, IgnoreEvolutionPolicy, StrictEvolutionPolicy}
import com.landoop.streamreactor.connect.hive.sink.partitioning.{DynamicPartitionHandler, PartitionHandler, StrictPartitionHandler}
import com.landoop.streamreactor.connect.hive.sink.staging._

import scala.collection.JavaConverters._

case class HiveSinkConfig(dbName: DatabaseName,
                          filenamePolicy: FilenamePolicy = DefaultFilenamePolicy,
                          stageManager: StageManager = new StageManager(DefaultFilenamePolicy),
                          tableOptions: Set[TableOptions] = Set.empty,
                          kerberos: Option[Kerberos],
                          hadoopConfiguration: HadoopConfiguration)

case class TableOptions(tableName: TableName,
                        topic: Topic,
                        createTable: Boolean = false,
                        overwriteTable: Boolean = false,
                        partitioner: PartitionHandler = new DynamicPartitionHandler(),
                        evolutionPolicy: EvolutionPolicy = IgnoreEvolutionPolicy,
                        projection: Option[NonEmptyList[Field]] = None,
                        // when creating a new table, the table will be partitioned with the fields set below
                        partitions: Seq[PartitionField] = Nil,
                        // the format used when creating a new table, if the table exists
                        // then the format will be derived from the table parameters
                        format: HiveFormat = ParquetHiveFormat,
                        commitPolicy: CommitPolicy = DefaultCommitPolicy(Some(1000 * 1000 * 128), None, None),
                        location: Option[String] = None)

object HiveSinkConfig {

  def fromProps(props: Map[String, String]): HiveSinkConfig = {

    import scala.concurrent.duration._

    val config = HiveSinkConfigDefBuilder(props.asJava)
    val tables = config.getKCQL.map { kcql =>

      val fields = Option(kcql.getFields).getOrElse(Collections.emptyList).asScala.toList
      val projection = if (fields.size == 1 && fields.head.getName == "*") None else NonEmptyList.fromList(fields)

      val flushSize = Option(kcql.getWithFlushSize).filter(_ > 0)
      val flushInterval = Option(kcql.getWithFlushInterval).filter(_ > 0).map(_.seconds)
      val flushCount = Option(kcql.getWithFlushCount).filter(_ > 0)

      // we must have at least one way of committing files
      val finalFlushSize = Some(flushSize.fold(1000L * 1000 * 128)(identity)) //if (flushSize.isEmpty ) Some(1000L * 1000 * 128) else flushSize

      val format: HiveFormat = HiveFormat(Option(kcql.getStoredAs).map(_.toLowerCase).getOrElse("parquet"))

      TableOptions(
        TableName(kcql.getTarget),
        Topic(kcql.getSource),
        kcql.isAutoCreate,
        kcql.getWithOverwrite,
        Option(kcql.getWithPartitioningStrategy).getOrElse(PartitioningStrategy.DYNAMIC) match {
          case PartitioningStrategy.DYNAMIC => new DynamicPartitionHandler()
          case PartitioningStrategy.STRICT => StrictPartitionHandler
        },
        format = format,
        projection = projection,
        evolutionPolicy = Option(kcql.getWithSchemaEvolution).getOrElse(SchemaEvolution.MATCH) match {
          case SchemaEvolution.ADD => AddEvolutionPolicy
          case SchemaEvolution.IGNORE => IgnoreEvolutionPolicy
          case SchemaEvolution.MATCH => StrictEvolutionPolicy
        },
        partitions = Option(kcql.getPartitionBy).map(_.asScala).getOrElse(Nil).map(name => PartitionField(name)).toVector,
        commitPolicy = DefaultCommitPolicy(
          fileSize = finalFlushSize,
          interval = flushInterval,
          fileCount = flushCount
        ),
        location = Option(kcql.getWithTableLocation)
      )
    }

    HiveSinkConfig(
      dbName = DatabaseName(props(SinkConfigSettings.DatabaseNameKey)),
      filenamePolicy = DefaultFilenamePolicy,
      stageManager = new StageManager(DefaultFilenamePolicy),
      tableOptions = tables,
      kerberos = Kerberos.from(config, SinkConfigSettings),
      hadoopConfiguration = HadoopConfiguration.from(config, SinkConfigSettings)
    )
  }
} 

package com.landoop.streamreactor.connect.hive.sink.mapper

import cats.data.NonEmptyList
import com.datamountaineer.kcql.Field
import com.landoop.streamreactor.connect.hive.StructMapper
import org.apache.kafka.connect.data.{SchemaBuilder, Struct}


class ProjectionMapper(projection: NonEmptyList[Field]) extends StructMapper {

  override def map(input: Struct): Struct = {
    // the compatible output schema built from projected fields with aliases applied
    val builder = projection.foldLeft(SchemaBuilder.struct) { (builder, kcqlField) =>
      Option(input.schema.field(kcqlField.getName)).fold(sys.error(s"Missing field $kcqlField")) { field =>
        builder.field(kcqlField.getAlias, field.schema)
      }
    }
    val schema = builder.build()
    projection.foldLeft(new Struct(schema)) { (struct, field) =>
      struct.put(field.getAlias, input.get(field.getName))
    }
  }
} 

package com.landoop.streamreactor.connect.hive.source.config

import java.util.Collections

import cats.data.NonEmptyList
import com.landoop.streamreactor.connect.hive.{DatabaseName, HadoopConfiguration, TableName, Topic}
import com.landoop.streamreactor.connect.hive.kerberos.Kerberos

import scala.collection.JavaConverters._

case class ProjectionField(name: String, alias: String)

case class HiveSourceConfig(dbName: DatabaseName,
                            kerberos: Option[Kerberos],
                            hadoopConfiguration: HadoopConfiguration,
                            tableOptions: Set[SourceTableOptions] = Set.empty,
                            pollSize: Int = 1024)

case class SourceTableOptions(
  tableName: TableName,
  topic: Topic,
  projection: Option[NonEmptyList[ProjectionField]] = None,
  limit: Int = Int.MaxValue
)

object HiveSourceConfig {

  def fromProps(props: Map[String, String]): HiveSourceConfig = {

    val config = HiveSourceConfigDefBuilder(props.asJava)
    val tables = config.getKCQL.map { kcql =>
      val fields = Option(kcql.getFields)
        .getOrElse(Collections.emptyList)
        .asScala
        .toList
        .map { field =>
          ProjectionField(field.getName, field.getAlias)
        }

      val projection = fields match {
        case Nil                              => None
        case ProjectionField("*", "*") :: Nil => None
        case _                                => NonEmptyList.fromList(fields)
      }

      SourceTableOptions(
        TableName(kcql.getSource),
        Topic(kcql.getTarget),
        projection,
        limit = if (kcql.getLimit < 1) Int.MaxValue else kcql.getLimit
      )
    }

    HiveSourceConfig(
      dbName = DatabaseName(props(HiveSourceConfigConstants.DatabaseNameKey)),
      tableOptions = tables,
      kerberos = Kerberos.from(config, HiveSourceConfigConstants),
      hadoopConfiguration =
        HadoopConfiguration.from(config, HiveSourceConfigConstants),
      pollSize = props
        .getOrElse(HiveSourceConfigConstants.PollSizeKey, 1024)
        .toString
        .toInt
    )
  }
} 

package com.landoop.streamreactor.connect.hive.source.mapper

import cats.data.NonEmptyList
import com.landoop.streamreactor.connect.hive.StructMapper
import com.landoop.streamreactor.connect.hive.source.config.ProjectionField
import org.apache.kafka.connect.data.{SchemaBuilder, Struct}

class ProjectionMapper(projection: NonEmptyList[ProjectionField]) extends StructMapper {

  override def map(input: Struct): Struct = {
    val builder = projection.foldLeft(SchemaBuilder.struct) { (builder, projectionField) =>
      Option(input.schema.field(projectionField.name))
        .fold(sys.error(s"Projection field ${projectionField.name} cannot be found in input")) { field =>
          builder.field(projectionField.alias, field.schema)
        }
    }
    val schema = builder.build()
    projection.foldLeft(new Struct(schema)) { (struct, field) =>
      struct.put(field.alias, input.get(field.name))
    }
  }
} 

package com.landoop.streamreactor.connect.hive.sink.mapper

import cats.data.NonEmptyList
import com.landoop.streamreactor.connect.hive.{PartitionKey, PartitionPlan, TableName}
import org.apache.kafka.connect.data.{SchemaBuilder, Struct}
import org.scalatest.funsuite.AnyFunSuite
import org.scalatest.matchers.should.Matchers

import scala.collection.JavaConverters._

class DropPartitionValuesMapperTest extends AnyFunSuite with Matchers {

  test("strip partition values") {

    val schema = SchemaBuilder.struct()
      .field("a", SchemaBuilder.string().required().build())
      .field("p", SchemaBuilder.string().required().build())
      .field("q", SchemaBuilder.string().required().build())
      .field("z", SchemaBuilder.string().required().build())
      .build()

    val plan = PartitionPlan(TableName("foo"), NonEmptyList.of(PartitionKey("p"), PartitionKey("q")))
    val struct = new Struct(schema).put("a", "a").put("p", "p").put("q", "q").put("z", "z")
    val output = new DropPartitionValuesMapper(plan).map(struct)
    output.schema().fields().asScala.map(_.name) shouldBe Seq("a", "z")
  }

  test("handle partition field is missing in input") {

    val schema = SchemaBuilder.struct()
      .field("a", SchemaBuilder.string().required().build())
      .field("q", SchemaBuilder.string().required().build())
      .field("z", SchemaBuilder.string().required().build())
      .build()


    val plan = PartitionPlan(TableName("foo"), NonEmptyList.of(PartitionKey("p"), PartitionKey("q")))
    val struct = new Struct(schema).put("a", "a").put("q", "q").put("z", "z")
    val output = new DropPartitionValuesMapper(plan).map(struct)
    output.schema().fields().asScala.map(_.name) shouldBe Seq("a", "z")
  }
} 

package com.wavesplatform.transaction.validation.impl

import cats.data.NonEmptyList
import cats.data.Validated.{Invalid, Valid}
import cats.implicits._
import com.wavesplatform.lang.v1.compiler.Terms.FUNCTION_CALL
import com.wavesplatform.lang.v1.{ContractLimits, FunctionHeader}
import com.wavesplatform.protobuf.transaction.PBTransactions
import com.wavesplatform.transaction.TxValidationError.{GenericError, NonPositiveAmount, TooBigArray}
import com.wavesplatform.transaction.smart.InvokeScriptTransaction
import com.wavesplatform.transaction.smart.InvokeScriptTransaction.Payment
import com.wavesplatform.transaction.validation.{TxValidator, ValidatedNV, ValidatedV}
import com.wavesplatform.utils._

import scala.util.Try

object InvokeScriptTxValidator extends TxValidator[InvokeScriptTransaction] {
  override def validate(tx: InvokeScriptTransaction): ValidatedV[InvokeScriptTransaction] = {
    import tx._

    def checkAmounts(payments: Seq[Payment]): ValidatedNV = {
      val invalid = payments.filter(_.amount <= 0)
      if (invalid.nonEmpty)
        Invalid(NonEmptyList.fromListUnsafe(invalid.toList).map(p => NonPositiveAmount(p.amount, p.assetId.fold("Waves")(_.toString))))
      else Valid(())
    }

    def checkLength =
      if (tx.isProtobufVersion)
        PBTransactions
          .toPBInvokeScriptData(tx.dAppAddressOrAlias, tx.funcCallOpt, tx.payments)
          .toByteArray
          .length <= ContractLimits.MaxInvokeScriptSizeInBytes
      else tx.bytes().length <= ContractLimits.MaxInvokeScriptSizeInBytes

    val callableNameSize =
      funcCallOpt match {
        case Some(FUNCTION_CALL(FunctionHeader.User(internalName, _), _)) => internalName.utf8Bytes.length
        case _ => 0
      }

    V.seq(tx)(
      V.addressChainId(dAppAddressOrAlias, chainId),
      V.cond(
        funcCallOpt.isEmpty || funcCallOpt.get.args.size <= ContractLimits.MaxInvokeScriptArgs,
        GenericError(s"InvokeScript can't have more than ${ContractLimits.MaxInvokeScriptArgs} arguments")
      ),
      V.cond(
        callableNameSize <= ContractLimits.MaxDeclarationNameInBytes,
        GenericError(s"Callable function name size = $callableNameSize bytes must be less than ${ContractLimits.MaxDeclarationNameInBytes}")
      ),
      checkAmounts(payments),
      V.fee(fee),
      Try(checkLength)
        .toEither
        .leftMap(err => GenericError(err.getMessage))
        .filterOrElse(identity, TooBigArray)
        .toValidatedNel
        .map(_ => ())
    )
  }
} 

package com.wavesplatform.mining

import cats.data.NonEmptyList
import com.wavesplatform.state.{Blockchain, Diff}
import com.wavesplatform.transaction.Transaction

trait MiningConstraint {
  def isFull: Boolean
  def isOverfilled: Boolean
  def put(blockchain: Blockchain, x: Transaction, diff: Diff): MiningConstraint
}

object MiningConstraint {
  case object Unlimited extends MiningConstraint {
    override def isFull: Boolean                                                           = false
    override def isOverfilled: Boolean                                                     = false
    override def put(blockchain: Blockchain, x: Transaction, diff: Diff): MiningConstraint = this
  }
}

case class OneDimensionalMiningConstraint(rest: Long, estimator: TxEstimators.Fn, description: String) extends MiningConstraint {
  override def isFull: Boolean = {
    rest < estimator.minEstimate
  }
  override def isOverfilled: Boolean = {
    rest < 0
  }
  override def put(blockchain: Blockchain, x: Transaction, diff: Diff): OneDimensionalMiningConstraint = put(estimator(blockchain, x, diff))
  private def put(x: Long): OneDimensionalMiningConstraint = {
    copy(rest = this.rest - x)
  }

  override def toString: String = {
    s"MiningConstraint(${if (description.isEmpty) "???" else description}, rest = $rest, estimator = $estimator)"
  }
}

case class MultiDimensionalMiningConstraint(constraints: NonEmptyList[MiningConstraint]) extends MiningConstraint {
  override def isFull: Boolean       = constraints.exists(_.isFull)
  override def isOverfilled: Boolean = constraints.exists(_.isOverfilled)
  override def put(blockchain: Blockchain, x: Transaction, diff: Diff): MultiDimensionalMiningConstraint =
    MultiDimensionalMiningConstraint(constraints.map(_.put(blockchain, x, diff)))
}

object MultiDimensionalMiningConstraint {
  val unlimited = MultiDimensionalMiningConstraint(NonEmptyList.of(MiningConstraint.Unlimited))

  def apply(constraint1: MiningConstraint, constraint2: MiningConstraint): MultiDimensionalMiningConstraint =
    MultiDimensionalMiningConstraint(NonEmptyList.of(constraint1, constraint2))

  def formatOverfilledConstraints(currRest: MultiDimensionalMiningConstraint, updatedRest: MultiDimensionalMiningConstraint): Iterator[String] = {
    if (currRest.constraints.length == updatedRest.constraints.length) {
      (for ((curr, upd) <- currRest.constraints.toList.iterator.zip(updatedRest.constraints.toList.iterator) if upd.isOverfilled)
        yield (curr, upd) match {
          case (OneDimensionalMiningConstraint(rest, _, description), OneDimensionalMiningConstraint(newRest, _, _)) =>
            Iterator.single(s"$description($rest -> $newRest)")

          case (m: MultiDimensionalMiningConstraint, m1: MultiDimensionalMiningConstraint) =>
            Iterator.empty ++ formatOverfilledConstraints(m, m1)

          case _ =>
            Iterator.single(s"$curr -> $upd")
        }).flatten
    } else {
      updatedRest.constraints.toList.iterator
        .filter(_.isOverfilled)
        .map(_.toString)
    }
  }
} 

package com.wavesplatform.mining

import cats.data.NonEmptyList
import com.wavesplatform.block.Block
import com.wavesplatform.features.BlockchainFeatures
import com.wavesplatform.settings.MinerSettings
import com.wavesplatform.state.Blockchain

case class MiningConstraints(total: MiningConstraint, keyBlock: MiningConstraint, micro: MiningConstraint)

object MiningConstraints {
  val MaxScriptRunsInBlock = 100
  val MaxScriptsComplexityInBlock = 1000000
  val ClassicAmountOfTxsInBlock = 100
  val MaxTxsSizeInBytes = 1 * 1024 * 1024 // 1 megabyte

  def apply(blockchain: Blockchain, height: Int, minerSettings: Option[MinerSettings] = None): MiningConstraints = {
    val activatedFeatures     = blockchain.activatedFeaturesAt(height)
    val isNgEnabled           = activatedFeatures.contains(BlockchainFeatures.NG.id)
    val isMassTransferEnabled = activatedFeatures.contains(BlockchainFeatures.MassTransfer.id)
    val isScriptEnabled       = activatedFeatures.contains(BlockchainFeatures.SmartAccounts.id)
    val isDAppsEnabled        = activatedFeatures.contains(BlockchainFeatures.Ride4DApps.id)

    val total: MiningConstraint =
      if (isMassTransferEnabled) OneDimensionalMiningConstraint(MaxTxsSizeInBytes, TxEstimators.sizeInBytes, "MaxTxsSizeInBytes")
      else {
        val maxTxs = if (isNgEnabled) Block.MaxTransactionsPerBlockVer3 else ClassicAmountOfTxsInBlock
        OneDimensionalMiningConstraint(maxTxs, TxEstimators.one, "MaxTxs")
      }

    new MiningConstraints(
      total =
        if (isDAppsEnabled)
          MultiDimensionalMiningConstraint(
            NonEmptyList
              .of(OneDimensionalMiningConstraint(MaxScriptsComplexityInBlock, TxEstimators.scriptsComplexity, "MaxScriptsComplexityInBlock"), total))
        else if (isScriptEnabled)
          MultiDimensionalMiningConstraint(
            NonEmptyList.of(OneDimensionalMiningConstraint(MaxScriptRunsInBlock, TxEstimators.scriptRunNumber, "MaxScriptRunsInBlock"), total))
        else total,
      keyBlock =
        if (isNgEnabled) OneDimensionalMiningConstraint(0, TxEstimators.one, "MaxTxsInKeyBlock")
        else OneDimensionalMiningConstraint(ClassicAmountOfTxsInBlock, TxEstimators.one, "MaxTxsInKeyBlock"),
      micro =
        if (isNgEnabled && minerSettings.isDefined)
          OneDimensionalMiningConstraint(minerSettings.get.maxTransactionsInMicroBlock, TxEstimators.one, "MaxTxsInMicroBlock")
        else MiningConstraint.Unlimited
    )
  }
} 

// Copyright (c) 2020 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

package com.daml.extractor.services

import cats.data.NonEmptyList
import cats.implicits._

import doobie._
import io.circe._
import io.circe.parser._

import org.postgresql.util.PGobject

trait Types {
  implicit val jsonGet: Get[Json] =
    Get.Advanced.other[PGobject](NonEmptyList.of("jsonb")).tmap[Json] { o =>
      parse(o.getValue).leftMap[Json](throw _).merge
    }

  case class ContractResult(
      event_id: String,
      archived_by_event_id: Option[String],
      contract_id: String,
      transaction_id: String,
      archived_by_transaction_id: Option[String],
      is_root_event: Boolean,
      package_id: String,
      template: String,
      create_arguments: Json,
      stakeholders: Json
  )

  case class TransactionResult(
      transaction_id: String,
      seq: Int,
      workflow_id: String,
      effective_at: java.sql.Timestamp,
      extracted_at: java.sql.Timestamp,
      ledger_offset: String
  )

  case class ExerciseResult(
      event_id: String,
      transaction_id: String,
      is_root_event: Boolean,
      contract_id: String,
      package_id: String,
      template: String,
      choice: String,
      choice_argument: Json,
      acting_parties: Json,
      consuming: Boolean,
      witness_parties: Json,
      child_event_ids: Json
  )
}

object Types extends Types 

package jbok.core.consensus

import cats.data.NonEmptyList
import jbok.core.consensus.Consensus._
import jbok.core.ledger.TypedBlock.{ExecutedBlock, MinedBlock}
import jbok.core.models.{Block, BlockHeader}


trait Consensus[F[_]] {
  def prepareHeader(parentOpt: Option[Block]): F[BlockHeader]

  def mine(executed: ExecutedBlock[F]): F[MinedBlock]

  def verify(block: Block): F[Unit]

  def run(block: Block): F[Result]

  def resolveBranch(headers: List[BlockHeader]): F[BranchResult]
}

object Consensus {
  sealed trait Result
  final case class Forward(blocks: List[Block])                         extends Result
  final case class Fork(oldBranch: List[Block], newBranch: List[Block]) extends Result
  final case class Stash(block: Block)                                  extends Result
  final case class Discard(reason: Throwable)                           extends Result

  sealed trait BranchResult
  final case class BetterBranch(newBranch: NonEmptyList[BlockHeader]) extends BranchResult
  final case object NoChainSwitch                                     extends BranchResult
  final case object InvalidBranch                                     extends BranchResult
} 

package retcalc

import cats.data.Validated._
import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import retcalc.RetCalcError.{InvalidArgument, InvalidNumber, RetCalcResult}

object SimulatePlanApp extends App {
  strMain(args) match {
    case Invalid(err) =>
      println(err)
      sys.exit(1)

    case Valid(result) =>
      println(result)
      sys.exit(0)
  }

  def parseInt(name: String, value: String): RetCalcResult[Int] =
    Validated
      .catchOnly[NumberFormatException](value.toInt)
      .leftMap(_ => NonEmptyList.of(InvalidNumber(name, value)))

  def parseParams(args: Array[String]): RetCalcResult[RetCalcParams] =
    (
      parseInt("nbOfYearsRetired", args(2)),
      parseInt("netIncome", args(3)),
      parseInt("currentExpenses", args(4)),
      parseInt("initialCapital", args(5))
    ).mapN { case (nbOfYearsRetired, netIncome, currentExpenses, initialCapital) =>
      RetCalcParams(
        nbOfMonthsInRetirement = nbOfYearsRetired * 12,
        netIncome = netIncome,
        currentExpenses = currentExpenses,
        initialCapital = initialCapital)
    }

  def parseFromUntil(fromUntil: String): RetCalcResult[(String, String)] = {
    val array = fromUntil.split(",")
    if (array.length != 2)
      InvalidArgument(name = "fromUntil", value = fromUntil, expectedFormat = "from,until"
      ).invalidNel
    else
      (array(0), array(1)).validNel
  }

  def strSimulatePlan(returns: Returns, nbOfYearsSaving: Int, params: RetCalcParams)
  : RetCalcResult[String] = {
    RetCalc.simulatePlan(
      returns = returns,
      params = params,
      nbOfMonthsSavings = nbOfYearsSaving * 12
    ).map {
      case (capitalAtRetirement, capitalAfterDeath) =>
        val nbOfYearsInRetirement = params.nbOfMonthsInRetirement / 12
        s"""
           |Capital after $nbOfYearsSaving years of savings:    ${capitalAtRetirement.round}
           |Capital after $nbOfYearsInRetirement years in retirement: ${capitalAfterDeath.round}
           |""".stripMargin
    }.toValidatedNel
  }


  def strMain(args: Array[String]): Validated[String, String] = {
    if (args.length != 6)
      """Usage:
        |simulatePlan from,until nbOfYearsSaving nbOfYearsRetired netIncome currentExpenses initialCapital
        |
        |Example:
        |simulatePlan 1952.09,2017.09 25 40 3000 2000 10000
        |""".stripMargin.invalid
    else {
      val allReturns = Returns.fromEquityAndInflationData(
        equities = EquityData.fromResource("sp500.tsv"),
        inflations = InflationData.fromResource("cpi.tsv"))

      val vFromUntil = parseFromUntil(args(0))
      val vNbOfYearsSaving = parseInt("nbOfYearsSaving", args(1))
      val vParams = parseParams(args)

      (vFromUntil, vNbOfYearsSaving, vParams)
        .tupled
        .andThen { case ((from, until), nbOfYearsSaving, params) =>
          strSimulatePlan(allReturns.fromUntil(from, until), nbOfYearsSaving, params)
        }
        .leftMap(nel => nel.map(_.message).toList.mkString("\n"))
    }
  }
}

case class SimulatePlanArgs(fromMonth: String,
                            untilMonth: String,
                            retCalcParams: RetCalcParams,
                            nbOfMonthsSavings: Int) 

package eu.timepit.refined.cats

import cats.data.{NonEmptyList, ValidatedNec, ValidatedNel}
import cats.syntax.either._
import eu.timepit.refined.api.RefinedTypeOps
import eu.timepit.refined.types.numeric.PosInt

object syntax extends CatsRefinedTypeOpsSyntax with CatsNonEmptyListSyntax

trait CatsRefinedTypeOpsSyntax {
  implicit class CatsRefinedTypeOps[FTP, T](rtOps: RefinedTypeOps[FTP, T]) {
    def validate(t: T): ValidatedNel[String, FTP] =
      validateNel(t)

    def validateNec(t: T): ValidatedNec[String, FTP] =
      rtOps.from(t).toValidatedNec

    def validateNel(t: T): ValidatedNel[String, FTP] =
      rtOps.from(t).toValidatedNel
  }
}

trait CatsNonEmptyListSyntax {
  implicit class CatsNonEmptyListRefinedOps[A](nel: NonEmptyList[A]) {
    def refinedSize: PosInt = PosInt.unsafeFrom(nel.size)
  }
} 

package com.wavesplatform.dex.api.ws.protocol

import cats.data.NonEmptyList
import cats.syntax.option._
import com.wavesplatform.dex.api.ws.entities.WsFullOrder
import com.wavesplatform.dex.domain.model.Denormalization
import com.wavesplatform.dex.error.ErrorFormatterContext
import com.wavesplatform.dex.model.AcceptedOrder
import com.wavesplatform.dex.model.Events.{OrderCanceled, OrderExecuted}
import play.api.libs.functional.syntax._
import play.api.libs.json._

case class WsOrdersUpdate(orders: NonEmptyList[WsFullOrder], timestamp: Long = System.currentTimeMillis) extends WsServerMessage {
  override val tpe: String = WsOrdersUpdate.tpe

  def append(other: WsOrdersUpdate): WsOrdersUpdate = copy(
    orders = other.orders ::: orders,
    timestamp = other.timestamp
  )
}

object WsOrdersUpdate {

  val tpe = "osu"

  def from(x: OrderCanceled)(implicit efc: ErrorFormatterContext): WsOrdersUpdate = WsOrdersUpdate(
    NonEmptyList.one(WsFullOrder.from(x))
  )

  def from(x: OrderExecuted, ts: Long)(implicit efc: ErrorFormatterContext): WsOrdersUpdate = {
    val ao1       = x.counterRemaining
    val assetPair = ao1.order.assetPair

    val amountAssetDecimals = efc.assetDecimals(assetPair.amountAsset)
    val priceAssetDecimals  = efc.assetDecimals(assetPair.priceAsset)

    def denormalizeAmount(value: Long): Double = Denormalization.denormalizeAmountAndFee(value, amountAssetDecimals).toDouble
    def denormalizePrice(value: Long): Double  = Denormalization.denormalizePrice(value, amountAssetDecimals, priceAssetDecimals).toDouble

    def from(ao: AcceptedOrder): WsFullOrder =
      WsFullOrder.from(
        ao,
        x,
        denormalizeAmount,
        denormalizePrice,
        Denormalization.denormalizeAmountAndFee(_, efc.assetDecimals(ao.feeAsset)).toDouble
      )

    WsOrdersUpdate(NonEmptyList.of(ao1, x.submittedRemaining).map(from), timestamp = ts)
  }

  def wsUnapply(arg: WsOrdersUpdate): Option[(String, Long, NonEmptyList[WsFullOrder])] = (arg.tpe, arg.timestamp, arg.orders).some

  implicit def nonEmptyListFormat[T: Format]: Format[NonEmptyList[T]] = Format(
    Reads.list[T].flatMap { xs =>
      NonEmptyList.fromList(xs).fold[Reads[NonEmptyList[T]]](Reads.failed("The list is empty"))(Reads.pure(_))
    },
    Writes.list[T].contramap(_.toList)
  )

  implicit val wsOrdersUpdateFormat: Format[WsOrdersUpdate] = (
    (__ \ "T").format[String] and
      (__ \ "_").format[Long] and
      (__ \ "o").format(nonEmptyListFormat[WsFullOrder])
  )(
    (_, ts, orders) => WsOrdersUpdate(orders, ts),
    unlift(WsOrdersUpdate.wsUnapply)
  )
} 

package com.wavesplatform.dex.settings

import cats.data.NonEmptyList
import cats.syntax.apply._
import com.wavesplatform.dex.settings.utils.ConfigSettingsValidator
import com.wavesplatform.dex.settings.utils.ConfigSettingsValidator.{ErrorsListOr, _}
import net.ceedubs.ficus.Ficus._
import net.ceedubs.ficus.readers.ValueReader

case class OrderRestrictionsSettings(stepAmount: Double, minAmount: Double, maxAmount: Double, stepPrice: Double, minPrice: Double, maxPrice: Double)

object OrderRestrictionsSettings {

  val Default =
    OrderRestrictionsSettings(
      stepAmount = 0.00000001,
      minAmount = 0.00000001,
      maxAmount = 1000000000,
      stepPrice = 0.00000001,
      minPrice = 0.00000001,
      maxPrice = 1000000
    )

  implicit val orderRestrictionsSettingsReader: ValueReader[OrderRestrictionsSettings] = { (cfg, path) =>
    val cfgValidator = ConfigSettingsValidator(cfg)

    def validateSizeMinMax(stepSettingName: String,
                           minSettingName: String,
                           maxSettingName: String,
                           stepDefaultValue: Double,
                           minDefaultValue: Double,
                           maxDefaultValue: Double): ErrorsListOr[(Double, Double, Double)] = {

      def validateSetting(settingName: String, defaultValue: Double): ErrorsListOr[Double] =
        cfgValidator.validateByPredicateWithDefault[Double](settingName)(_ > 0, s"required 0 < value", defaultValue)

      (
        validateSetting(stepSettingName, stepDefaultValue),
        validateSetting(minSettingName, minDefaultValue),
        validateSetting(maxSettingName, maxDefaultValue)
      ).mapN(Tuple3.apply)
        .ensure(NonEmptyList(s"Required $minSettingName < $maxSettingName", Nil)) { case (_, min, max) => min < max }
    }

    (
      validateSizeMinMax(s"$path.step-amount", s"$path.min-amount", s"$path.max-amount", Default.stepAmount, Default.minAmount, Default.maxAmount),
      validateSizeMinMax(s"$path.step-price", s"$path.min-price", s"$path.max-price", Default.stepPrice, Default.minPrice, Default.maxPrice),
    ) mapN {
      case ((stepAmount, minAmount, maxAmount), (stepPrice, minPrice, maxPrice)) =>
        OrderRestrictionsSettings(stepAmount, minAmount, maxAmount, stepPrice, minPrice, maxPrice)
    } getValueOrThrowErrors
  }
} 

package com.wavesplatform.dex.caches

import java.util.concurrent.ConcurrentHashMap

import cats.data.NonEmptyList
import com.wavesplatform.dex.domain.asset.{Asset, AssetPair}
import com.wavesplatform.dex.domain.utils.ScorexLogging
import com.wavesplatform.dex.settings.{DenormalizedMatchingRule, MatcherSettings, MatchingRule}

import scala.util.Try
import scala.util.control.NonFatal

class MatchingRulesCache(matcherSettings: MatcherSettings) extends ScorexLogging {

  private val allMatchingRules    = new ConcurrentHashMap[AssetPair, NonEmptyList[DenormalizedMatchingRule]]
  private val currentMatchingRule = new ConcurrentHashMap[AssetPair, DenormalizedMatchingRule]

  def getMatchingRules(assetPair: AssetPair, assetDecimals: Asset => Int): NonEmptyList[DenormalizedMatchingRule] = {
    allMatchingRules.computeIfAbsent(
      assetPair,
      _ => DenormalizedMatchingRule.getDenormalizedMatchingRules(matcherSettings, assetDecimals, assetPair)
    )
  }

  // DEX-488 TODO remove after found a reason of NPE
  def getDenormalizedRuleForNextOrder(assetPair: AssetPair, currentOffset: Long, assetDecimals: Asset => Int): DenormalizedMatchingRule = {

    lazy val defaultRule = DenormalizedMatchingRule.getDefaultRule(assetPair, assetDecimals)

    val result =
      Try {
        getMatchingRules(assetPair, assetDecimals).foldLeft(defaultRule) { case (acc, mr) => if (mr.startOffset <= (currentOffset + 1)) mr else acc }
      }.recover { case NonFatal(e) => log.error(s"Can't get a denormalized rule for a next order", e); defaultRule }
        .getOrElse(defaultRule)

    result.copy(tickSize = result.tickSize max defaultRule.tickSize)
  }

  def getNormalizedRuleForNextOrder(assetPair: AssetPair, currentOffset: Long, assetDecimals: Asset => Int): MatchingRule = {
    getDenormalizedRuleForNextOrder(assetPair, currentOffset, assetDecimals).normalize(assetPair, assetDecimals)
  }

  def updateCurrentMatchingRule(assetPair: AssetPair, denormalizedMatchingRule: DenormalizedMatchingRule): Unit = {
    currentMatchingRule.put(assetPair, denormalizedMatchingRule)
  }

  def setCurrentMatchingRuleForNewOrderBook(assetPair: AssetPair, currentOffset: Long, assetDecimals: Asset => Int): Unit = {
    updateCurrentMatchingRule(assetPair, getDenormalizedRuleForNextOrder(assetPair, currentOffset, assetDecimals))
  }
} 

package sup.data

import cats.data.NonEmptyList
import cats.implicits._
import cats.Apply
import cats.Functor
import cats.NonEmptyParallel
import cats.NonEmptyTraverse
import cats.Parallel
import cats.Reducible
import sup._

object HealthReporter {

  
  def parWrapChecks[F[_]: NonEmptyParallel: Functor, G[_]: NonEmptyTraverse, H[_]: Reducible](
    checks: G[HealthCheck[F, H]]
  ): HealthReporter[F, G, H] = HealthCheck.liftF {

    Parallel.parNonEmptyTraverse(checks)(_.check).map(fromResults[G, H])
  }

  def fromResults[G[_]: Reducible: Functor, H[_]: Reducible](
    results: G[HealthResult[H]]
  ): HealthResult[Report[G, H, ?]] =
    HealthResult(Report.fromResults[G, H, Health](results.map(_.value)))
} 

package com.timeout.docless.swagger

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.instances.all._
import cats.syntax.eq._
import cats.syntax.foldable._
import cats.syntax.monoid._
import cats.{Eq, Monoid}
import com.timeout.docless.schema.JsonSchema.{Definition, TypeRef}

trait PathGroup {
  def params: List[OperationParameter] = Nil

  def definitions: List[Definition]

  def paths: List[Path]
}

object PathGroup {
  val Empty = PathGroup(Nil, Nil, Nil)

  def aggregate(
      info: Info,
      groups: List[PathGroup],
      securitySchemes: List[SecurityScheme] = Nil
  ): ValidatedNel[SchemaError, APISchema] = {
    val g          = groups.combineAll
    val allDefs    = g.definitions
    val definedIds = allDefs.map(_.id).toSet
    val securityDefinitions = SecurityDefinitions(securitySchemes: _*)

    def isDefined(ctx: RefWithContext): Boolean =
      allDefs.exists(_.id === ctx.ref.id)

    val missingDefinitions =
      allDefs.foldMap { d =>
        d.relatedRefs.collect {
          case r @ TypeRef(id, _) if !definedIds.exists(_ === id) =>
            SchemaError.missingDefinition(RefWithContext.definition(r, d))
        }
      }

    val errors =
      g.paths
        .foldMap(_.refs.filterNot(isDefined))
        .map(SchemaError.missingDefinition)
        .toList ++ missingDefinitions

    if (errors.nonEmpty)
      Validated.invalid[NonEmptyList[SchemaError], APISchema](
        NonEmptyList.fromListUnsafe(errors)
      )
    else
      Validated.valid {
        APISchema(
          info = info,
          host = "http://example.com/",
          basePath = "/",
          parameters = OperationParameters(g.params),
          paths = Paths(g.paths),
          schemes = Set(Scheme.Http),
          consumes = Set("application/json"),
          produces = Set("application/json"),
          securityDefinitions = securityDefinitions
        ).defining(g.definitions: _*)
      }
  }

  def apply(ps: List[Path],
            defs: List[Definition],
            _params: List[OperationParameter]): PathGroup =
    new PathGroup {

      override val paths       = ps
      override val definitions = defs
      override val params      = _params
    }

  implicit val pgEq: Eq[PathGroup] = Eq.fromUniversalEquals

  implicit def pgMonoid: Monoid[PathGroup] = new Monoid[PathGroup] {
    override def empty: PathGroup = Empty

    override def combine(x: PathGroup, y: PathGroup): PathGroup =
      PathGroup(
        x.paths |+| y.paths,
        x.definitions |+| y.definitions,
        x.params |+| y.params
      )
  }

} 

package com.timeout.docless.swagger

import org.scalatest.{FreeSpec, Inside, Matchers}
import cats.data.NonEmptyList
import cats.data.Validated
import SchemaError._
import com.timeout.docless.schema.JsonSchema
import com.timeout.docless.schema.JsonSchema._
import com.timeout.docless.swagger.Method._

class PathGroupTest extends FreeSpec with Matchers {
  "PathGroup" - {
    val petstore = PetstoreSchema()
    val pet      = PetstoreSchema.Schemas.pet

    val paths     = Path("/example") :: petstore.paths.get.toList
    val defs      = petstore.definitions.get.toList
    val defsNoPet = defs.filterNot(_.id === pet.id)
    val params    = petstore.parameters.get.toList

    val group1          = PathGroup(paths, defs, params)
    val group2          = PathGroup(List(Path("/extra")), Nil, Nil)
    val groupMissingErr = PathGroup(paths, defsNoPet, params)

    def err(path: String, m: Method, f: Definition => Ref): SchemaError =
      missingDefinition(RefWithContext.response(f(pet.definition), m, path))

    "aggregate" - {
      "when some top level definitions are missing" - {
        "returns the missing refs" in {
          PathGroup.aggregate(petstore.info, List(groupMissingErr)) should ===(
            Validated.invalid[NonEmptyList[SchemaError], APISchema](
              NonEmptyList.of(
                err("/pets", Get, ArrayRef.apply),
                err("/pets", Post, TypeRef.apply),
                err("/pets/{id}", Get, TypeRef.apply),
                err("/pets/{id}", Delete, TypeRef.apply)
              )
            )
          )
        }
      }
      "when some nested definitions are missing" - {
        val info = Info("example")
        case class Nested(name: String)
        case class TopLevel(nested: Nested)

        val schema = JsonSchema.deriveFor[TopLevel]
        val nested = schema.relatedDefinitions.head

        val paths = List(
          "/example".Post(
            Operation('_, "...")
              .withParams(BodyParameter(schema = Some(schema.asRef)))
          )
        )

        val withNested    = PathGroup(paths, schema.definitions.toList, Nil)
        val withoutNested = PathGroup(paths, List(schema.definition), Nil)

        "returns the missing refs" in {
          PathGroup.aggregate(info, List(withNested)).isValid shouldBe true
          PathGroup.aggregate(info, List(withoutNested)) should ===(
            Validated.invalid[NonEmptyList[SchemaError], APISchema](
              NonEmptyList.of(
                MissingDefinition(
                  RefWithContext.definition(nested.asRef, schema.definition)
                )
              )
            )
          )
        }
      }
      "when no definition is missing" - {
        "returns a valid api schema" in new Inside {
          inside(PathGroup.aggregate(petstore.info, List(group1, group2))) {
            case Validated.Valid(schema) =>
              schema.info should ===(petstore.info)
              schema.paths.get should ===(group1.paths ++ group2.paths)
              schema.definitions.get should ===(
                group1.definitions ++ group2.definitions
              )
              schema.parameters.get should ===(group1.params ++ group2.params)
          }
        }
      }
    }
  }
} 

package roc
package postgresql

import cats.data.NonEmptyList
import org.scalacheck.Prop.forAll
import org.scalacheck.Gen
import org.specs2._
import roc.postgresql.failures._

final class FailuresSpec extends Specification with ScalaCheck { def is = s2"""

  Failure
    ReadyForQueryDecodingFailure should have correct message         $readyForQueryDecodingFailure
    UnknownAuthenticationFailure should have correct message         $unknownAuthRequestFailure
    UnsupportedAuthenticationFailure should have correct message     $unsupportedAuthFailure
    PostgresqlStateMachineFailure should have correct message        $postgresqlStateMachineFailure
    UnknownPostgresqlMessageTypeFailure should have correct message  $unknownPostgresqlMessageTypeFailure
    PostgresqlMessageDecodingFailure must have a correct error message   $postgresqlMessageDecodingFailure
                                                                         """

  val readyForQueryDecodingFailure = forAll { c: Char =>
    val msg = s"Received unexpected Char $c from Postgres Server."
    val error = new ReadyForQueryDecodingFailure(c)
    error.getMessage must_== msg
  }

  val unknownAuthRequestFailure = forAll { n: Int =>
    val expectedMessage = s"Unknown Authentication Request Type: $n"
    val error           = new UnknownAuthenticationRequestFailure(n)
    error.getMessage must_== expectedMessage
  }

  val unsupportedAuthFailure = forAll { s: String =>
    val expectedMessage =
      s"Unsupported Authentication Failure. $s authentication is not supported."
    val error           = new UnsupportedAuthenticationFailure(s)
    error.getMessage must_== expectedMessage
  }
  
  val postgresqlStateMachineFailure = forAll { (s1: String, s2: String) =>
    val expectedMessage = s"State Transition from $s1 -> $s2 is undefined."
    val error           = new PostgresqlStateMachineFailure(s1, s2)
    error.getMessage must_== expectedMessage
  }
  
  val unknownPostgresqlMessageTypeFailure = forAll { c: Char =>
    val expectedMessage = s"Unknown Postgresql MessageType '$c'."
    val error           = new UnknownPostgresqlMessageTypeFailure(c)
    error.getMessage must_== expectedMessage
  }

  val postgresqlMessageDecodingFailure = forAll(genNELErrorResponse) { nel: NonEmptyList[String] =>
    val error = new PostgresqlMessageDecodingFailure(nel)
    val expectedMessage = nel.foldLeft("")(_ + _)
    expectedMessage must_== error.getMessage
  }

  private lazy val genErrorResponseString: Gen[String] = Gen.oneOf(
    "Required Severity Level was not present.",
    "Required SQLSTATE Code was not present.",
    "Required Message was not present."
  )
  private lazy val genNELErrorResponse: Gen[NonEmptyList[String]] = for {
    string  <-  genErrorResponseString
  } yield NonEmptyList.of(string)

} 

package octopus.cats

import cats.data.{NonEmptyList, Validated}
import octopus.example.domain._
import octopus.syntax._
import octopus.{Fixtures, ValidationError}
import org.scalatest.matchers.must.Matchers
import org.scalatest.wordspec.AnyWordSpec

class CatsIntegrationSpec
  extends AnyWordSpec with Matchers with Fixtures {

  "Cats Integration" should {

    "support ValidatedNel" when {

      "Valid scenario" in {
        1.validate.toValidatedNel mustBe Validated.Valid(1)
        userId_Valid.validate.toValidatedNel mustBe Validated.Valid(userId_Valid)
        user_Valid.validate.toValidatedNel mustBe Validated.Valid(user_Valid)
      }

      "Invalid scenario" in {

        userId_Invalid.validate.toValidatedNel mustBe Validated.Invalid(
          NonEmptyList.of(ValidationError(UserId.Err_MustBePositive))
        )

        user_Invalid1.validate.toValidatedNel.leftMap(_.map(_.toPair)) mustBe Validated.Invalid(
          NonEmptyList.of(
            "id" -> UserId.Err_MustBePositive,
            "email" -> Email.Err_MustContainAt,
            "email" -> Email.Err_MustContainDotAfterAt,
            "address.postalCode" -> PostalCode.Err_MustBeLengthOf5,
            "address.postalCode" -> PostalCode.Err_MustContainOnlyDigits,
            "address.city" -> Address.Err_MustNotBeEmpty,
            "address.street" -> Address.Err_MustNotBeEmpty
          )
        )
      }
    }

    "support Validated" when {

      "Valid scenario" in {
        1.validate.toValidated mustBe Validated.Valid(1)
        userId_Valid.validate.toValidated mustBe Validated.Valid(userId_Valid)
        user_Valid.validate.toValidated mustBe Validated.Valid(user_Valid)
      }

      "Invalid scenario" in {

        userId_Invalid.validate.toValidated mustBe Validated.Invalid(
          List(ValidationError(UserId.Err_MustBePositive))
        )

        user_Invalid1.validate.toValidated.leftMap(_.map(_.toPair)) mustBe Validated.Invalid(
          List(
            "id" -> UserId.Err_MustBePositive,
            "email" -> Email.Err_MustContainAt,
            "email" -> Email.Err_MustContainDotAfterAt,
            "address.postalCode" -> PostalCode.Err_MustBeLengthOf5,
            "address.postalCode" -> PostalCode.Err_MustContainOnlyDigits,
            "address.city" -> Address.Err_MustNotBeEmpty,
            "address.street" -> Address.Err_MustNotBeEmpty
          )
        )
      }
    }
  }

} 

package hydra.ingest.modules

import java.time.Instant

import cats.data.NonEmptyList
import cats.effect.Sync
import cats.implicits._
import cats.{Monad, MonadError}
import hydra.core.marshallers.History
import hydra.ingest.app.AppConfig.V2MetadataTopicConfig
import hydra.kafka.model._
import hydra.kafka.programs.CreateTopicProgram
import hydra.kafka.util.KafkaUtils.TopicDetails

final class Bootstrap[F[_]: MonadError[*[_], Throwable]] private (
    createTopicProgram: CreateTopicProgram[F],
    cfg: V2MetadataTopicConfig
) {

  def bootstrapAll: F[Unit] =
    for {
      _ <- bootstrapMetadataTopic
    } yield ()

  private def bootstrapMetadataTopic: F[Unit] =
    if (cfg.createOnStartup) {
      TopicMetadataV2.getSchemas[F].flatMap { schemas =>
        createTopicProgram.createTopic(
          cfg.topicName,
          TopicMetadataV2Request(
            schemas,
            StreamTypeV2.Entity,
            false,
            InternalUseOnly,
            NonEmptyList.of(cfg.contactMethod),
            Instant.now,
            List.empty,
            Some(
              "This is the topic that Hydra uses to keep track of metadata for topics."
            )
          ),
          TopicDetails(cfg.numPartitions, cfg.replicationFactor)
        )
      }
    } else {
      Monad[F].unit
    }

}

object Bootstrap {

  def make[F[_]: Sync](
      createTopicProgram: CreateTopicProgram[F],
      v2MetadataTopicConfig: V2MetadataTopicConfig
  ): F[Bootstrap[F]] = Sync[F].delay {
    new Bootstrap[F](createTopicProgram, v2MetadataTopicConfig)
  }
} 

package hydra.kafka.algebras

import java.time.Instant

import cats.data.NonEmptyList
import cats.effect.{Concurrent, ContextShift, IO, Sync, Timer}
import cats.implicits._
import hydra.avro.registry.SchemaRegistry
import hydra.core.marshallers.History
import hydra.kafka.algebras.MetadataAlgebra.TopicMetadataContainer
import hydra.kafka.model.ContactMethod.Slack
import hydra.kafka.model.TopicMetadataV2Request.Subject
import hydra.kafka.model.{Public, StreamTypeV2, TopicMetadataV2, TopicMetadataV2Key, TopicMetadataV2Request, TopicMetadataV2Value}
import io.chrisdavenport.log4cats.SelfAwareStructuredLogger
import io.chrisdavenport.log4cats.slf4j.Slf4jLogger
import org.apache.avro.generic.GenericRecord
import org.scalatest.Assertion
import org.scalatest.matchers.should.Matchers
import org.scalatest.wordspec.AnyWordSpecLike
import retry.RetryPolicies._
import retry.syntax.all._
import retry.{RetryPolicy, _}

import scala.concurrent.ExecutionContext
import scala.concurrent.duration._

class MetadataAlgebraSpec extends AnyWordSpecLike with Matchers {

  implicit private val contextShift: ContextShift[IO] = IO.contextShift(ExecutionContext.global)
  private implicit val concurrentEffect: Concurrent[IO] = IO.ioConcurrentEffect

  private implicit val policy: RetryPolicy[IO] = limitRetries[IO](5) |+| exponentialBackoff[IO](500.milliseconds)
  private implicit val timer: Timer[IO] = IO.timer(ExecutionContext.global)
  private implicit def noop[A]: (A, RetryDetails) => IO[Unit] = retry.noop[IO, A]

  implicit private def unsafeLogger[F[_]: Sync]: SelfAwareStructuredLogger[F] =
    Slf4jLogger.getLogger[F]

  private implicit class RetryAndAssert[A](boolIO: IO[A]) {
    def retryIfFalse(check: A => Boolean): IO[Assertion] =
      boolIO.map(check).retryingM(identity, policy, noop).map(assert(_))
  }


  private val metadataTopicName = "_internal.metadataTopic"
  private val consumerGroup = "Consumer Group"

  (for {
    kafkaClient <- KafkaClientAlgebra.test[IO]
    schemaRegistry <- SchemaRegistry.test[IO]
    metadata <- MetadataAlgebra.make(metadataTopicName, consumerGroup, kafkaClient, schemaRegistry, consumeMetadataEnabled = true)
  } yield {
    runTests(metadata, kafkaClient)
  }).unsafeRunSync()

  private def runTests(metadataAlgebra: MetadataAlgebra[IO], kafkaClientAlgebra: KafkaClientAlgebra[IO]): Unit = {
    "MetadataAlgebraSpec" should {

      "retrieve none for non-existant topic" in {
        val subject = Subject.createValidated("Non-existantTopic").get
        metadataAlgebra.getMetadataFor(subject).unsafeRunSync() shouldBe None
      }

      "retrieve metadata" in {
        val subject = Subject.createValidated("subject1").get
        val (genericRecordsIO, key, value) = getMetadataGenericRecords(subject)

        (for {
          record <- genericRecordsIO
          _ <- kafkaClientAlgebra.publishMessage(record, metadataTopicName)
          _ <- metadataAlgebra.getMetadataFor(subject).retryIfFalse(_.isDefined)
          metadata <- metadataAlgebra.getMetadataFor(subject)
        } yield metadata shouldBe Some(TopicMetadataContainer(key, value, None, None))).unsafeRunSync()
      }

      "retrieve all metadata" in {
        val subject = Subject.createValidated("subject2").get
        val (genericRecordsIO, key, value) = getMetadataGenericRecords(subject)
        (for {
          record <- genericRecordsIO
          _ <- kafkaClientAlgebra.publishMessage(record, metadataTopicName)
          _ <- metadataAlgebra.getMetadataFor(subject).retryIfFalse(_.isDefined)
          allMetadata <- metadataAlgebra.getAllMetadata
        } yield allMetadata should have length 2).unsafeRunSync()
      }
    }
  }

  private def getMetadataGenericRecords(subject: Subject): (IO[(GenericRecord, Option[GenericRecord])], TopicMetadataV2Key, TopicMetadataV2Value) = {
    val key = TopicMetadataV2Key(subject)
    val value = TopicMetadataV2Value(
        StreamTypeV2.Entity,
        deprecated = false,
        Public,
        NonEmptyList.one(Slack.create("#channel").get),
        Instant.now,
        List(),
        None)
    (TopicMetadataV2.encode[IO](key, Some(value)), key, value)
  }
} 

package tsec.oauth2.provider

import cats.implicits._
import java.net.URLDecoder
import cats.data.NonEmptyList

final case class FetchResult(token: String, params: Map[String, String])

sealed trait AccessTokenFetcher {
  def matches(request: ProtectedResourceRequest): Boolean
  def fetch(request: ProtectedResourceRequest): Either[InvalidRequest, FetchResult]
}

object AccessTokenFetcher {
  object RequestParameter extends AccessTokenFetcher {

    override def matches(request: ProtectedResourceRequest): Boolean =
      request.oauthToken.isDefined || request.accessToken.isDefined

    override def fetch(request: ProtectedResourceRequest): Either[InvalidRequest, FetchResult] = {
      val t      = request.oauthToken orElse (request.accessToken)
      val params = request.params.filter { case (_, v) => !v.isEmpty } map { case (k, v) => (k, v.head) }
      t.map(s => FetchResult(s, params - ("oauth_token", "access_token")))
        .toRight(InvalidRequest("missing access token"))
    }
  }

  object AuthHeader extends AccessTokenFetcher {
    val RegexpAuthorization = """^\s*(OAuth|Bearer)\s+([^\s\,]*)""".r
    val RegexpTrim          = """^\s*,\s*""".r
    val RegexpDivComma      = """,\s*""".r

    override def matches(request: ProtectedResourceRequest): Boolean =
      request.header("Authorization").exists { header =>
        RegexpAuthorization.findFirstMatchIn(header).isDefined
      }

    override def fetch(request: ProtectedResourceRequest): Either[InvalidRequest, FetchResult] =
      for {
        header  <- request.header("authorization").toRight(InvalidRequest("Missing authorization header"))
        matcher <- RegexpAuthorization.findFirstMatchIn(header).toRight(InvalidRequest("invalid Authorization header"))
        token = matcher.group(2)
        end   = matcher.end
        params <- if (header.length != end) {
          val trimmedHeader = RegexpTrim.replaceFirstIn(header.substring(end), "")
          val pairs = RegexpDivComma.split(trimmedHeader).map { exp =>
            val (key, value) = exp.split("=", 2) match {
              case Array(k, v) => (k, v.replaceFirst("^\"", ""))
              case Array(k)    => (k, "")
            }

            val v = Either.catchNonFatal(URLDecoder.decode(value.replaceFirst("\"$", ""), "UTF-8"))
            v.map(vv => (key, vv)).leftMap(t => NonEmptyList.one(t.getMessage))
          }

          pairs.toList.parSequence.map(x => Map(x: _*)).leftMap(x => InvalidRequest(x.toList.mkString(",")))
        } else {
          Right(Map.empty[String, String])
        }
      } yield FetchResult(token, params)
  }
} 

package tsec.jws.mac

import cats.data.NonEmptyList
import cats.syntax.either._
import io.circe._
import io.circe.syntax._
import tsec.common._
import tsec.jws.JWSSerializer
import tsec.jws.header.JWSHeader
import tsec.jwt
import tsec.jwt.algorithms.JWTMacAlgo
import tsec.jwt.header.JWTtyp


  implicit def decoder[A: JWTMacAlgo]: Decoder[JWSMacHeader[A]] = new Decoder[JWSMacHeader[A]] {
    def apply(c: HCursor): Either[DecodingFailure, JWSMacHeader[A]] =
      c.downField("alg")
        .as[String]
        .map(JWTMacAlgo.fromString[A]) match {
        case Right(opt) =>
          opt match {
            case Some(_) =>
              for {
                t     <- c.downField("typ").as[Option[JWTtyp]]
                cType <- c.downField("cty").as[Option[String]]
                crit  <- c.downField("crit").as[Option[NonEmptyList[String]]]
              } yield
                new JWSMacHeader[A](
                  `type` = t,
                  contentType = cType,
                  critical = crit
                ) {}
            case None =>
              Left(DecodingFailure("No algorithm found", Nil))
          }

        case Left(d) => Left(d)
      }
  }

  implicit def genSerializer[A: JWTMacAlgo](
      implicit d: Decoder[JWSMacHeader[A]],
      e: Encoder[JWSMacHeader[A]]
  ): JWSSerializer[JWSMacHeader[A]] =
    new JWSSerializer[JWSMacHeader[A]] {
      def serializeToUtf8(body: JWSMacHeader[A]): Array[Byte] = jwt.JWTPrinter.print(body.asJson).utf8Bytes

      def fromUtf8Bytes(array: Array[Byte]): Either[Error, JWSMacHeader[A]] =
        io.circe.parser.decode[JWSMacHeader[A]](array.toUtf8String)
    }
} 

package io.circe.schema

import cats.data.NonEmptyList
import org.everit.json.schema.ValidationException
import scala.collection.mutable.Builder

sealed abstract class ValidationError(
  val keyword: String,
  val location: String,
  val schemaLocation: Option[String]
) extends Exception {
  final override def fillInStackTrace(): Throwable = this
}

object ValidationError {
  def apply(
    keyword: String,
    message: String,
    location: String,
    schemaLocation: Option[String] = None
  ): ValidationError =
    new ValidationError(keyword, location, schemaLocation) {
      final override def getMessage: String = message
    }

  private[this] def fromEveritOne(e: ValidationException): ValidationError =
    apply(e.getKeyword, e.getMessage, e.getPointerToViolation, Option(e.getSchemaLocation))

  private[this] def fromEveritRecursive(
    e: ValidationException,
    builder: Builder[ValidationError, List[ValidationError]]
  ): Unit = {
    val nested = e.getCausingExceptions
    val iter = nested.iterator

    while (iter.hasNext) {
      builder += fromEveritOne(iter.next)
    }

    val iterRecursive = nested.iterator

    while (iterRecursive.hasNext) {
      fromEveritRecursive(iterRecursive.next, builder)
    }
  }

  private[schema] def fromEverit(e: ValidationException): NonEmptyList[ValidationError] = {
    val builder = List.newBuilder[ValidationError]
    fromEveritRecursive(e, builder)
    NonEmptyList(fromEveritOne(e), builder.result)
  }
} 

package higherkindness.skeuomorph.mu

import cats.data.NonEmptyList
import higherkindness.skeuomorph.mu.MuF._
import higherkindness.droste._


  def knownCoproductTypesTrans[T](implicit B: Basis[MuF, T]): Trans[MuF, MuF, T] =
    Trans {
      case TCoproduct(NonEmptyList(x, List(y))) =>
        (B.coalgebra(x), B.coalgebra(y)) match {
          case (_, TNull()) => TOption[T](x)
          case (TNull(), _) => TOption[T](y)
          case _            => TEither[T](x, y)
        }
      case other => other
    }

  def knownCoproductTypes[T: Basis[MuF, ?]]: T => T = scheme.cata(knownCoproductTypesTrans.algebra)
} 

package bad.robot.temperature.server

import java.net.InetAddress
import java.time.Clock

import bad.robot.temperature.IpAddress._
import bad.robot.temperature._
import cats.data.NonEmptyList
import cats.effect.IO
import cats.implicits._
import org.http4s._
import org.http4s.dsl.io._

object ConnectionsEndpoint {

  private implicit val encoder = jsonEncoder[List[Connection]]

  def apply(connections: Connections, ipAddresses: => NonEmptyList[Option[InetAddress]] = currentIpAddress)(implicit clock: Clock) = HttpService[IO] {
    case GET -> Root / "connections" => {
      Ok(connections.all).map(_.putHeaders(xForwardedHost(ipAddresses)))
    }

    case GET -> Root / "connections" / "active" / "within" / LongVar(period) / "mins" => {
      Ok(connections.allWithin(period)).map(_.putHeaders(xForwardedHost(ipAddresses)))
    }
  }

  private def xForwardedHost(ipAddresses: NonEmptyList[Option[InetAddress]]): Header = {
    Header("X-Forwarded-Host", ipAddresses.map(_.fold("unknown")(_.getHostAddress)).mkString_("", ", ", ""))
  }

} 

package endpoints4s.http4s.server

import cats.data.NonEmptyList
import cats.syntax.functor._
import endpoints4s.{Tupler, Valid}
import endpoints4s.algebra.BasicAuthentication.Credentials
import endpoints4s.algebra.Documentation
import org.http4s
import org.http4s.headers.{Authorization, `WWW-Authenticate`}
import org.http4s.{BasicCredentials, Challenge}


trait BasicAuthentication
    extends EndpointsWithCustomErrors
    with endpoints4s.algebra.BasicAuthentication {

  private val unauthorizedRequestResponse = http4s
    .Response[Effect](Unauthorized)
    .withHeaders(
      `WWW-Authenticate`(
        NonEmptyList.of(Challenge("Basic", "Realm", Map("charset" -> "UTF-8")))
      )
    )

  private[endpoints4s] def basicAuthenticationHeader: RequestHeaders[Option[Credentials]] =
    headers =>
      Valid(
        headers
          .get(Authorization)
          .flatMap { authHeader =>
            authHeader.credentials match {
              case BasicCredentials(username, password) =>
                Some(Credentials(username, password))
              case _ => None
            }
          }
      )

  def authenticatedRequest[U, E, H, UE, HC, Out](
      method: Method,
      url: Url[U],
      entity: RequestEntity[E],
      headers: RequestHeaders[H],
      requestDocs: Documentation = None
  )(implicit
      tuplerUE: Tupler.Aux[U, E, UE],
      tuplerHC: Tupler.Aux[H, Credentials, HC],
      tuplerUEHC: Tupler.Aux[UE, HC, Out]
  ): Request[Out] =
    extractUrlAndHeaders(method, url, headers ++ basicAuthenticationHeader) {
      case (_, (_, None)) =>
        _ => Effect.pure(Left(unauthorizedRequestResponse))
      case (u, (h, Some(credentials))) =>
        http4sRequest =>
          entity(http4sRequest)
            .map(
              _.map(e => tuplerUEHC(tuplerUE(u, e), tuplerHC(h, credentials)))
            )
    }

} 

import cats._
import cats.data.{EitherK, NonEmptyList}
import cats.free.Free
import cats.effect.Sync
import contextual._

package object hammock {

  import hammock.marshalling._
  import hammock.InterpTrans

  type HammockF[A] = EitherK[HttpF, MarshallF, A]

  implicit class HttpRequestIOSyntax[A](fa: Free[HttpF, A]) {
    def exec[F[_]: Sync](implicit interp: InterpTrans[F]): F[A] =
      fa foldMap interp.trans
  }

  implicit class HammockFSyntax[A](fa: Free[HammockF, A]) {
    def exec[F[_]: Sync](implicit NT: HammockF ~> F): F[A] =
      fa foldMap NT
  }

  implicit class AsSyntaxOnHttpF[F[_], A](fa: Free[F, HttpResponse])(
      implicit
      H: InjectK[HttpF, F]) {
    def as[B](implicit D: Decoder[B], M: MarshallC[EitherK[F, MarshallF, *]]): Free[EitherK[F, MarshallF, *], B] =
      fa.inject[EitherK[F, MarshallF, *]] flatMap { response =>
        M.unmarshall(response.entity)
      }
  }

  implicit def hammockNT[F[_]: Sync](
      implicit H: InterpTrans[F],
      M: MarshallF ~> F
  ): HammockF ~> F = H.trans or M

  object UriContext extends Context

  object UriInterpolator extends Interpolator {
    type Output      = Uri
    type ContextType = UriContext.type
    type Input       = String
    def contextualize(interpolation: StaticInterpolation) = {
      interpolation.parts.foldLeft(List.empty[ContextType]) {
        case (contexts, Hole(_, _)) => UriContext :: contexts
        case (contexts, _)          => contexts
      }
    }

    def evaluate(interpolation: RuntimeInterpolation): Uri = {
      val substituted = interpolation.literals
        .zipAll(interpolation.substitutions, "", "")
        .flatMap(x => List(x._1, x._2))
        .mkString("")
      Uri.fromString(substituted).right.get
    }

  }

  implicit val embedString = UriInterpolator.embed[String](Case(UriContext, UriContext) { x =>
    x
  })

  
  implicit class UriQueryParamsBuilder(val self: NonEmptyList[(String, String)]) extends AnyVal {
    def &(param: (String, String)): NonEmptyList[(String, String)] = param :: self
  }
  implicit class UriQueryInitBuilder(val self: (String, String)) extends AnyVal {
    def &(param: (String, String)): NonEmptyList[(String, String)] = NonEmptyList(self, param :: Nil)
  }
} 

package hammock

import atto._
import Atto._
import cats.Foldable
import cats.data.NonEmptyList
import cats.implicits._
import org.scalacheck._
import org.scalacheck.Prop._
import org.scalacheck.Gen

object UriProps extends Properties("Uri") {
  import Uri._
  import TestInstances._

  property("authority roudtrip") = forAll(authorityArbitrary.arbitrary) { auth: Authority =>
    Uri.Authority.parse.parseOnly(auth.show).either === Right(auth)
  }

  property("uri roudtrip") = forAll(uriArbitrary.arbitrary) { uri: Uri =>
    Uri.unsafeParse(uri.show) === uri
  }

  property("/ appends to the path") = forAll(uriArbitrary.arbitrary, nonEmptyAlphanumString) { (uri: Uri, toAppend: String) =>
    (uri / toAppend).path === uri.path ++ "/" ++ toAppend
  }

  property("param method appends parameter to the query") = forAll(uriArbitrary.arbitrary, nonEmptyAlphanumString, nonEmptyAlphanumString) { (uri: Uri, key: String, value: String) =>
    val query = uri.param(key, value).query
    query.contains(key) && query(key) === value
  }

  property("string interpolation") = forAll(nonEmptyAlphanumString, nonEmptyAlphanumString, nonEmptyAlphanumString) { (url: String, key1: String, value1: String) =>
    val substituedUri = uri"https://${url}?${key1}=${value1}&other=query"
    substituedUri.query.contains(key1) && substituedUri.query(key1) === value1
    substituedUri.show == s"https://${url}?${key1}=${value1}&other=query"
  }

  property("params method appends multiple parameters to the query") = forAll(uriArbitrary.arbitrary, Gen.listOf(nonEmptyStringPair)) { (uri, pairs) =>
    val query = uri.params(pairs: _*).query
    Foldable[List].foldLeft(pairs.map(pair => query.contains(pair._1)), true)(_ && _)
  }

  property("? method should do the same as 'params'") = forAll(uriArbitrary.arbitrary, Gen.nonEmptyListOf(nonEmptyStringPair)) { (uri, pairs) =>
    val result = uri ? NonEmptyList.fromListUnsafe(pairs)
    result === uri.copy(query = uri.query ++ pairs)
  }


} 

package io.chrisdavenport.cormorant
package fs2

import cats.data.NonEmptyList
import cats.effect._
import cats.effect.testing.specs2.CatsIO
import _root_.fs2.Stream
import io.chrisdavenport.cormorant._
// import io.chrisdavenport.cormorant.implicits._
// import scala.concurrent.duration._
import java.io.ByteArrayInputStream
import java.io.InputStream

class StreamingParserSpec extends CormorantSpec with CatsIO {

  def ruinDelims(str: String) = augmentString(str).flatMap {
    case '\n' => "\r\n"
    case c => c.toString
  }

  "Streaming Parser" should {
    // https://github.com/ChristopherDavenport/cormorant/pull/84
    "parse a known value that did not work with streaming" in {
      val x = """First Name,Last Name,Email
Larry,Bordowitz,[email protected]
Anonymous,Hippopotamus,[email protected]"""
      val source = IO.pure(new ByteArrayInputStream(ruinDelims(x).getBytes): InputStream)
      Stream.resource(Blocker[IO]).flatMap{blocker => 
        _root_.fs2.io.readInputStream(
          source,
          chunkSize = 4,
          blocker
        )
      }
        .through(_root_.fs2.text.utf8Decode)
        .through(parseComplete[IO])
        .compile
        .toVector
        .map{ v => 
          val header = CSV.Headers(NonEmptyList.of(CSV.Header("First Name"), CSV.Header("Last Name"), CSV.Header("Email")))
          val row1 = CSV.Row(NonEmptyList.of(CSV.Field("Larry"), CSV.Field("Bordowitz"), CSV.Field("[email protected]")))
          val row2 = CSV.Row(NonEmptyList.of(CSV.Field("Anonymous"), CSV.Field("Hippopotamus"), CSV.Field("[email protected]")))
          Vector(
            (header, row1),
            (header, row2)
          ) must_=== v
        }
    }
  }

  

} 

package io.chrisdavenport.cormorant.generic.internal

import io.chrisdavenport.cormorant._
import shapeless._
import shapeless.labelled._
import cats.implicits._
import cats.data.NonEmptyList

trait LabelledWriteProofs
  extends LowPriorityLabelledWriteProofs {

  
  implicit def deriveByNameHListPut[K <: Symbol, H, T <: HList](
      implicit witness: Witness.Aux[K],
      P: Put[H],
      labelledWrite: Lazy[LabelledWrite[T]]
  ): LabelledWrite[FieldType[K, H] :: T] =
    new LabelledWrite[FieldType[K, H] :: T] {
      def headers: CSV.Headers = {
        CSV.Headers(
          NonEmptyList.one(CSV.Header(witness.value.name)) <+>
          labelledWrite.value.headers.l
        )
      }
      def write(a: FieldType[K, H] :: T): CSV.Row =
        CSV.Row(P.put(a.head) :: labelledWrite.value.write(a.tail).l)
    }
}

private[internal] trait LowPriorityLabelledWriteProofs1
  extends LowPriorityLabelledWriteProofs2 {
  implicit def deriveByLabelledWrite2[K, H, T <: HList](
    implicit P: LabelledWrite[H],
    labelledWrite: Lazy[LabelledWrite[T]]
  ): LabelledWrite[FieldType[K, H] :: T] =
    new LabelledWrite[FieldType[K, H]:: T] {
      def headers: CSV.Headers = {
        CSV.Headers(
          P.headers.l <+>
          labelledWrite.value.headers.l
        )
      }
      def write(a: FieldType[K, H] :: T): CSV.Row = {
        CSV.Row(P.write(a.head).l.concatNel(labelledWrite.value.write(a.tail).l))
      }
    }
}

private[internal] trait LowPriorityLabelledWriteProofs2 {
  implicit def labelledWriteHNilGet[K, H](
    implicit W: LabelledWrite[H]
  ): LabelledWrite[FieldType[K, H] :: HNil] = 
    new LabelledWrite[FieldType[K, H] :: HNil] {
      def headers: CSV.Headers =
        W.headers
      def write(a: FieldType[K, H] :: HNil): CSV.Row = 
        W.write(a.head)
    }
  
} 

package io.chrisdavenport.cormorant.generic.internal

import io.chrisdavenport.cormorant._
import shapeless._
import cats.implicits._
import cats.data.NonEmptyList

trait ReadProofs extends LowPriorityReadProofs {

  implicit def readHNil[H](implicit G: Get[H]): Read[H :: HNil] = new Read[H :: HNil] {
    def readPartial(a: CSV.Row): Either[Error.DecodeFailure, Either[(CSV.Row, H :: HNil), H :: HNil]] = a match {
      case CSV.Row(NonEmptyList(f, Nil)) => 
        G.get(f).map(h => h :: HNil).map(Either.right)
      case CSV.Row(NonEmptyList(f, rest)) => 
        NonEmptyList.fromList(rest) match {
          case Some(nel) => 
            G.get(f).map(h => h :: HNil)
              .map(h => Either.left((CSV.Row(nel), h)))
          case None =>
            Either.left(Error.DecodeFailure.single(s"Unexpected Input: Did Not Expect - $a"))
        }
    }
  }

  implicit def hlistRead[H, T <: HList](
      implicit G: Get[H],
      R: Lazy[Read[T]]
  ): Read[H :: T] = new Read[H :: T] {
    def readPartial(a: CSV.Row): Either[Error.DecodeFailure, Either[(CSV.Row, H :: T), H :: T]] = a match {
      case CSV.Row(NonEmptyList(h, t)) =>
        (
          G.get(h),
          NonEmptyList.fromList(t)
          .fold(
            Either.left[Error.DecodeFailure, Either[(CSV.Row, T), T]](Error.DecodeFailure.single("Unexpected End Of Input"))
          )(nel =>
            R.value.readPartial(CSV.Row(nel))
          )
        ).parMapN{
          case (h, Left((row, t))) => Either.left((row, h :: t))
          case (h, Right(t)) => Either.right(h :: t)
        }
    }
  }
}

private[internal] trait LowPriorityReadProofs{
  implicit def hlistRead2[H, T <: HList](
    implicit RH: Lazy[Read[H]],
    RT: Lazy[Read[T]]
  ): Read[H :: T] = new Read[H :: T]{
    def readPartial(a: CSV.Row): Either[Error.DecodeFailure,Either[(CSV.Row, H :: T),H :: T]] = 
      RH.value.readPartial(a).flatMap{
        case Left((row, h)) => RT.value.readPartial(row).map{
          case Left((row, t)) => Left((row, h :: t))
          case Right(t) => Right(h:: t)
        }
        case Right(value) => 
          Either.left(Error.DecodeFailure.single(s"Incomplete Output - $value only"))
      }
  }
} 

package io.chrisdavenport.cormorant

import cats.data.NonEmptyList
import cats.Semigroup

import cats.implicits._

sealed trait Error extends Exception {
  final override def fillInStackTrace(): Throwable = this
  final override def getMessage: String = toString
  override def toString: String = this match {
    case Error.DecodeFailure(failure) => s"DecodeFailure($failure)"
    case Error.ParseFailure(reason) => s"ParseFailure($reason)"
    case Error.PrintFailure(reason) => s"PrintFailure($reason)"
  }
}
object Error {
  final case class ParseFailure(reason: String) extends Error
  object ParseFailure {
    def invalidInput(input: String): ParseFailure =
      ParseFailure(s"Invalid Input: Received $input")
  }

  final case class DecodeFailure(failure: NonEmptyList[String]) extends Error
  object DecodeFailure {
    def single(reason: String): DecodeFailure = DecodeFailure(NonEmptyList.of(reason))
    implicit val decodeFailureSemigroup: Semigroup[DecodeFailure] = {
      new Semigroup[DecodeFailure] {
        def combine(x: DecodeFailure, y: DecodeFailure): DecodeFailure =
          DecodeFailure(x.failure |+| y.failure)
      }
    }
  }

  final case class PrintFailure(reason: String) extends Error
} 

package org.scalasteward.core.bitbucketserver.http4s

import cats.data.NonEmptyList
import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
import io.circe.{Decoder, Encoder}
import org.http4s.Uri
import org.scalasteward.core.git.Sha1
import org.scalasteward.core.vcs.data.PullRequestState

object Json {
  case class Page[A](values: List[A])

  case class Repo(id: Int, name: String, forkable: Boolean, project: Project, links: Links)

  case class Project(key: String)

  type Links = Map[String, NonEmptyList[Link]]

  case class Link(href: Uri, name: Option[String])

  case class PR(title: String, state: PullRequestState, links: Links)

  case class NewPR(
      title: String,
      description: String,
      state: PullRequestState,
      open: Boolean,
      closed: Boolean,
      fromRef: Ref,
      toRef: Ref,
      locked: Boolean,
      reviewers: List[Reviewer]
  )

  case class Ref(id: String, repository: Repository)

  case class Repository(slug: String, project: Project)

  case class Condition(reviewers: List[DefaultReviewer])

  case class DefaultReviewer(name: String)

  case class Reviewer(user: User)

  case class User(name: String)

  case class Branches(values: NonEmptyList[Branch])

  case class Branch(id: String, latestCommit: Sha1)

  implicit def pageDecode[A: Decoder]: Decoder[Page[A]] = deriveDecoder
  implicit val repoDecode: Decoder[Repo] = deriveDecoder
  implicit val projectDecode: Decoder[Project] = deriveDecoder
  implicit val linkDecoder: Decoder[Link] = deriveDecoder
  implicit val uriDecoder: Decoder[Uri] = Decoder.decodeString.map(Uri.unsafeFromString)
  implicit val prDecoder: Decoder[PR] = deriveDecoder
  implicit val reviewerDecoder: Decoder[Reviewer] = deriveDecoder
  implicit val userDecoder: Decoder[User] = deriveDecoder
  implicit val defaultReviewerDecoder: Decoder[DefaultReviewer] = deriveDecoder
  implicit val conditionDecoder: Decoder[Condition] = deriveDecoder
  implicit val branchDecoder: Decoder[Branch] = deriveDecoder
  implicit val branchesDecoder: Decoder[Branches] = deriveDecoder

  implicit val encodeNewPR: Encoder[NewPR] = deriveEncoder
  implicit val encodeRef: Encoder[Ref] = deriveEncoder
  implicit val encodeRepository: Encoder[Repository] = deriveEncoder
  implicit val encodeProject: Encoder[Project] = deriveEncoder
  implicit val encodeReviewer: Encoder[Reviewer] = deriveEncoder
  implicit val encodeUser: Encoder[User] = deriveEncoder
} 

package org.adridadou.openlaw.result

import cats.implicits._
import cats.data.NonEmptyList

import scala.concurrent.{Await, Future}
import scala.concurrent.duration.Duration
import scala.language.implicitConversions
import scala.util.{Try, Failure => TFailure, Success => TSuccess}

object Implicits {

  implicit class RichNonEmptyList[T](val nel: NonEmptyList[T]) extends AnyVal {
    def mkString: String = mkString(", ")
    def mkString(sep: String): String = nel.toList.mkString(sep)
  }

  implicit class RichTry[T](val t: Try[T]) extends AnyVal {
    def toResult: Result[T] = t match {
      case TSuccess(v)            => Success(v)
      case TFailure(e: Exception) => Failure(e)

      // don't try to handle Error instances
      case TFailure(t) => throw t
    }
  }

  implicit class RichEither[T](val either: Either[String, T]) extends AnyVal {
    def toResult: Result[T] = either.left.map(FailureMessage(_))
  }

  implicit class RichFuture[T](val future: Future[T]) extends AnyVal {
    def getResult(timeout: Duration): Result[T] =
      attempt(Await.result(future, timeout))
  }

  implicit class RichResult[T](val result: Result[T]) extends AnyVal {
    def addCause(cause: Failure[T]): ResultNel[T] = result match {
      case Success(_)     => cause.toResultNel
      case Left(original) => FailureNel(original, cause.value)
    }
    def addFailure[U >: T](cause: FailureCause): ResultNel[U] = result match {
      case s @ Success(_) => s.toResultNel
      case Left(original) => FailureNel(cause, original)
    }
    def addMessageToFailure[U >: T](message: String): ResultNel[U] =
      result match {
        case s @ Success(_) => s.toResultNel
        case Left(original) => FailureNel(FailureMessage(message), original)
      }
    def convert(pf: PartialFunction[Exception, Exception]): Result[T] =
      result.left.map {
        case FailureException(e, _) if pf.isDefinedAt(e) =>
          FailureException(pf(e))
        case f => f
      }
    def recoverMerge(f: FailureCause => T): T =
      result.fold(failure => f(failure), success => success)
    def recoverWith(pf: PartialFunction[FailureCause, Result[T]]): Result[T] =
      result.leftFlatMap { error =>
        if (pf.isDefinedAt(error)) {
          pf(error)
        } else {
          result
        }
      }
    def toResultNel: ResultNel[T] = result.toValidatedNel
    def toFuture: Future[T] = result match {
      case Success(value) => Future.successful(value)
      case Failure(e, _)  => Future.failed(e)
    }
    def getOrThrow(): T = result.valueOr(_.throwException())
  }

  implicit class RichOption[T](val option: Option[T]) extends AnyVal {
    def toResult(message: String): Result[T] =
      option.map(x => Success(x)).getOrElse(Failure(message))
  }

  implicit class RichResultNel[T](val result: ResultNel[T]) extends AnyVal {
    def toUnit: ResultNel[Unit] = result.map(_ => ())
    def toResult: Result[T] = result.toEither.leftMap {
      case NonEmptyList(x, Seq()) => x
      case nel                    => FailureException(MultipleCauseException(nel))
    }
  }

  implicit def exception2Result[A](e: Exception): Result[A] = Failure[A](e)
  implicit def unitResultConversion[T](wrapped: Result[T]): Result[Unit] =
    wrapped.map(_ => ())
  implicit def failureCause2Exception[T](wrapped: FailureCause): Exception =
    wrapped.e
} 

package org.adridadou.openlaw.result

import cats.data.NonEmptyList
import Implicits.RichNonEmptyList

final case class MultipleCauseException(causes: NonEmptyList[FailureCause])
    extends java.lang.RuntimeException(causes.map(_.message).mkString)

trait FailureCause {
  def e: Exception
  def id: String
  def throwException[T](): T = throw e
  def message: String = Option(e.getMessage).getOrElse("")
}

object FailureCause {
  def unapply(result: Result[_]): Option[FailureCause] = result.swap.toOption
}

final case class FailureException(
    override val e: Exception,
    idOpt: Option[String] = None
) extends FailureCause {
  override val id = idOpt.getOrElse(message)
}

final case class FailureMessage(
    override val message: String,
    idOpt: Option[String] = None
) extends FailureCause {
  override val e = new RuntimeException(message)
  override val id = idOpt.getOrElse(message)
} 

package org.adridadou.openlaw

import result.Implicits.RichResult
import cats.data.Validated._
import cats.data.{NonEmptyList, ValidatedNel}
import cats.data.NonEmptyList.{of, one}
import cats.implicits._
import org.adridadou.openlaw.result.Implicits.RichTry
import scala.util.Try
import scala.util.control.NonFatal

package object result {

  type ResultNel[+A] = ValidatedNel[FailureCause, A]

  type Result[+A] = Either[FailureCause, A]
  type Failure[Nothing] = Left[FailureCause, Nothing]
  type Success[+A] = Right[FailureCause, A]

  def attempt[A](f: => A): Result[A] = Try(f).toResult

  def handleFatalErrors(t: Throwable): Result[Nothing] = t match {
    case NonFatal(e: Exception) => Failure(e)
    case e                      => throw e
  }
}

package result {

  object Success {
    def unit: Result[Unit] = Success(())
    def apply[A](a: A): Result[A] = Right(a)
    def unapply[A](result: Result[A]): Option[A] = result.toOption
  }

  object ResultNel {
    def apply[A](nel: NonEmptyList[Result[A]]): ResultNel[NonEmptyList[A]] =
      nel.map(_.toResultNel).sequence
    def apply[A](nel: List[Result[A]]): ResultNel[List[A]] =
      nel.map(_.toResultNel).sequence
  }

  object FailureNel {
    def apply[A](e: FailureCause): ResultNel[A] =
      Invalid[NonEmptyList[FailureCause]](one(e))
    def apply[A](head: FailureCause, tail: FailureCause*): ResultNel[A] =
      Invalid[NonEmptyList[FailureCause]](of(head, tail: _*))
  }

  object Failure {
    def apply[A](f: FailureCause): Result[A] = Left(f)
    def apply[A](): Result[A] = apply(new RuntimeException)
    def apply[A](e: Exception): Result[A] = apply(FailureException(e))
    def apply[A](e: Exception, id: String): Result[A] =
      apply(FailureException(e, Some(id)))
    def apply[A](message: String): Result[A] = apply(FailureMessage(message))
    def apply[A](message: String, id: String): Result[A] =
      apply(FailureMessage(message, Some(id)))
    def apply[A](es: NonEmptyList[Exception]): ResultNel[A] =
      Invalid(es.map(FailureException(_)))
    // implicits are necessary here to disambiguate arguments after erasure
    def apply[A](
        es: NonEmptyList[(Exception, String)]
    )(implicit i: DummyImplicit): ResultNel[A] =
      Invalid(es.map { case (e, id) => FailureException(e, Some(id)) })
    def apply[A](
        messages: NonEmptyList[String]
    )(implicit i: DummyImplicit, i2: DummyImplicit): ResultNel[A] =
      Invalid(messages.map(FailureMessage(_)))
    def apply[A](messages: NonEmptyList[(String, String)])(
        implicit i: DummyImplicit,
        i2: DummyImplicit,
        i3: DummyImplicit
    ): ResultNel[A] =
      Invalid(messages.map { case (m, id) => FailureMessage(m, Some(id)) })
    def unapply(result: Result[_]): Option[(Exception, String)] =
      result.swap.toOption.map { f =>
        (f.e, f.id)
      }
  }
} 

package dev.profunktor.fs2rabbit.examples

import cats.data.NonEmptyList
import cats.effect._
import cats.syntax.functor._
import dev.profunktor.fs2rabbit.config.{Fs2RabbitConfig, Fs2RabbitNodeConfig}
import dev.profunktor.fs2rabbit.interpreter.RabbitClient
import dev.profunktor.fs2rabbit.resiliency.ResilientStream
import monix.eval.{Task, TaskApp}
import java.util.concurrent.Executors

object MonixAutoAckConsumer extends TaskApp {

  private val config: Fs2RabbitConfig = Fs2RabbitConfig(
    virtualHost = "/",
    nodes = NonEmptyList.one(
      Fs2RabbitNodeConfig(
        host = "127.0.0.1",
        port = 5672
      )
    ),
    username = Some("guest"),
    password = Some("guest"),
    ssl = false,
    connectionTimeout = 3,
    requeueOnNack = false,
    requeueOnReject = false,
    internalQueueSize = Some(500),
    automaticRecovery = true
  )

  val blockerResource =
    Resource
      .make(Task(Executors.newCachedThreadPool()))(es => Task(es.shutdown()))
      .map(Blocker.liftExecutorService)

  override def run(args: List[String]): Task[ExitCode] =
    blockerResource.use { blocker =>
      RabbitClient[Task](config, blocker).flatMap { client =>
        ResilientStream
          .runF(new AutoAckConsumerDemo[Task](client).program)
          .as(ExitCode.Success)
      }
    }

} 

package dev.profunktor.fs2rabbit.examples

import java.util.concurrent.Executors

import cats.data.NonEmptyList
import cats.effect._
import cats.syntax.functor._
import dev.profunktor.fs2rabbit.config.{Fs2RabbitConfig, Fs2RabbitNodeConfig}
import dev.profunktor.fs2rabbit.interpreter.RabbitClient
import dev.profunktor.fs2rabbit.resiliency.ResilientStream

object IOAckerConsumer extends IOApp {

  private val config: Fs2RabbitConfig = Fs2RabbitConfig(
    virtualHost = "/",
    nodes = NonEmptyList.one(Fs2RabbitNodeConfig(host = "127.0.0.1", port = 5672)),
    username = Some("guest"),
    password = Some("guest"),
    ssl = false,
    connectionTimeout = 3,
    requeueOnNack = false,
    requeueOnReject = false,
    internalQueueSize = Some(500),
    automaticRecovery = true
  )

  val blockerResource =
    Resource
      .make(IO(Executors.newCachedThreadPool()))(es => IO(es.shutdown()))
      .map(Blocker.liftExecutorService)

  override def run(args: List[String]): IO[ExitCode] =
    blockerResource.use { blocker =>
      RabbitClient[IO](config, blocker).flatMap { client =>
        ResilientStream
          .runF(new AckerConsumerDemo[IO](client).program)
          .as(ExitCode.Success)
      }
    }
} 

package dev.profunktor.fs2rabbit.algebra

import cats.data.NonEmptyList
import cats.effect.{Resource, Sync}
import cats.implicits._
import com.rabbitmq.client.{Address, ConnectionFactory, DefaultSaslConfig, SaslConfig}
import dev.profunktor.fs2rabbit.config.Fs2RabbitConfig
import dev.profunktor.fs2rabbit.effects.Log
import dev.profunktor.fs2rabbit.javaConversion._
import dev.profunktor.fs2rabbit.model.{AMQPChannel, AMQPConnection, RabbitChannel, RabbitConnection}
import javax.net.ssl.SSLContext

object ConnectionResource {
  type ConnectionResource[F[_]] = Connection[Resource[F, ?]]
  def make[F[_]: Sync: Log](
      conf: Fs2RabbitConfig,
      sslCtx: Option[SSLContext] = None,
      // Unlike SSLContext, SaslConfig is not optional because it is always set
      // by the underlying Java library, even if the user doesn't set it.
      saslConf: SaslConfig = DefaultSaslConfig.PLAIN
  ): F[Connection[Resource[F, ?]]] =
    Sync[F].delay {
      new Connection[Resource[F, ?]] {

        private[fs2rabbit] def mkConnectionFactory: F[(ConnectionFactory, NonEmptyList[Address])] =
          Sync[F].delay {
            val factory   = new ConnectionFactory()
            val firstNode = conf.nodes.head
            factory.setHost(firstNode.host)
            factory.setPort(firstNode.port)
            factory.setVirtualHost(conf.virtualHost)
            factory.setConnectionTimeout(conf.connectionTimeout)
            factory.setAutomaticRecoveryEnabled(conf.automaticRecovery)
            if (conf.ssl) {
              sslCtx.fold(factory.useSslProtocol())(factory.useSslProtocol)
            }
            factory.setSaslConfig(saslConf)
            conf.username.foreach(factory.setUsername)
            conf.password.foreach(factory.setPassword)
            val addresses = conf.nodes.map(node => new Address(node.host, node.port))
            (factory, addresses)
          }

        private[fs2rabbit] def acquireChannel(connection: AMQPConnection): F[AMQPChannel] =
          Sync[F]
            .delay(connection.value.createChannel)
            .flatTap(c => Log[F].info(s"Acquired channel: $c"))
            .map(RabbitChannel)

        private[fs2rabbit] val acquireConnection: F[AMQPConnection] =
          mkConnectionFactory.flatMap {
            case (factory, addresses) =>
              Sync[F]
                .delay(factory.newConnection(addresses.toList.asJava))
                .flatTap(c => Log[F].info(s"Acquired connection: $c"))
                .map(RabbitConnection)
          }

        override def createConnection: Resource[F, AMQPConnection] =
          Resource.make(acquireConnection) {
            case RabbitConnection(conn) =>
              Log[F].info(s"Releasing connection: $conn previously acquired.") *>
                Sync[F].delay {
                  if (conn.isOpen) conn.close()
                }
          }

        override def createChannel(connection: AMQPConnection): Resource[F, AMQPChannel] =
          Resource.make(acquireChannel(connection)) {
            case RabbitChannel(channel) =>
              Sync[F].delay {
                if (channel.isOpen) channel.close()
              }
          }
      }
    }
}

trait Connection[F[_]] {
  def createConnection: F[AMQPConnection]
  def createChannel(connection: AMQPConnection): F[AMQPChannel]
} 

package dev.profunktor.fs2rabbit.config

import cats.data.NonEmptyList

case class Fs2RabbitNodeConfig(
    host: String,
    port: Int
)

case class Fs2RabbitConfig(
    nodes: NonEmptyList[Fs2RabbitNodeConfig],
    virtualHost: String,
    connectionTimeout: Int,
    ssl: Boolean,
    username: Option[String],
    password: Option[String],
    requeueOnNack: Boolean,
    requeueOnReject: Boolean,
    internalQueueSize: Option[Int],
    automaticRecovery: Boolean
)

object Fs2RabbitConfig {
  def apply(
      host: String,
      port: Int,
      virtualHost: String,
      connectionTimeout: Int,
      ssl: Boolean,
      username: Option[String],
      password: Option[String],
      requeueOnNack: Boolean,
      requeueOnReject: Boolean,
      internalQueueSize: Option[Int],
      automaticRecovery: Boolean = true
  ): Fs2RabbitConfig = Fs2RabbitConfig(
    nodes = NonEmptyList.one(Fs2RabbitNodeConfig(host, port)),
    virtualHost = virtualHost,
    connectionTimeout = connectionTimeout,
    ssl = ssl,
    username = username,
    password = password,
    requeueOnNack = requeueOnNack,
    requeueOnReject = requeueOnReject,
    internalQueueSize = internalQueueSize,
    automaticRecovery = automaticRecovery
  )
} 

package docspell.joex.fts

import cats.data.{Kleisli, NonEmptyList}
import cats.effect._
import cats.implicits._
import cats.{ApplicativeError, FlatMap, Semigroup}

import docspell.common._
import docspell.ftsclient._
import docspell.joex.Config
import docspell.joex.scheduler.Context
import docspell.store.queries.{QAttachment, QItem}

object FtsWork {
  def apply[F[_]](f: FtsContext[F] => F[Unit]): FtsWork[F] =
    Kleisli(f)

  def all[F[_]: FlatMap](
      m0: FtsWork[F],
      mn: FtsWork[F]*
  ): FtsWork[F] =
    NonEmptyList.of(m0, mn: _*).reduce(semigroup[F])

  implicit def semigroup[F[_]: FlatMap]: Semigroup[FtsWork[F]] =
    Semigroup.instance((mt1, mt2) => mt1.flatMap(_ => mt2))

  // some tasks

  def log[F[_]](f: Logger[F] => F[Unit]): FtsWork[F] =
    FtsWork(ctx => f(ctx.logger))

  def initialize[F[_]]: FtsWork[F] =
    FtsWork(_.fts.initialize)

  def clearIndex[F[_]](coll: Option[Ident]): FtsWork[F] =
    coll match {
      case Some(cid) =>
        FtsWork(ctx => ctx.fts.clear(ctx.logger, cid))
      case None =>
        FtsWork(ctx => ctx.fts.clearAll(ctx.logger))
    }

  def insertAll[F[_]: Effect](coll: Option[Ident]): FtsWork[F] =
    FtsWork
      .all(
        FtsWork(ctx =>
          ctx.fts.indexData(
            ctx.logger,
            ctx.store
              .transact(
                QAttachment
                  .allAttachmentMetaAndName(coll, ctx.cfg.migration.indexAllChunk)
              )
              .map(caa =>
                TextData
                  .attachment(
                    caa.item,
                    caa.id,
                    caa.collective,
                    caa.lang,
                    caa.name,
                    caa.content
                  )
              )
          )
        ),
        FtsWork(ctx =>
          ctx.fts.indexData(
            ctx.logger,
            ctx.store
              .transact(QItem.allNameAndNotes(coll, ctx.cfg.migration.indexAllChunk * 5))
              .map(nn => TextData.item(nn.id, nn.collective, Option(nn.name), nn.notes))
          )
        )
      )

  object syntax {
    implicit final class FtsWorkOps[F[_]](mt: FtsWork[F]) {
      def ++(mn: FtsWork[F])(implicit ev: FlatMap[F]): FtsWork[F] =
        all(mt, mn)

      def recoverWith(
          other: FtsWork[F]
      )(implicit ev: ApplicativeError[F, Throwable]): FtsWork[F] =
        Kleisli(ctx => mt.run(ctx).onError({ case _ => other.run(ctx) }))

      def forContext(
          cfg: Config.FullTextSearch,
          fts: FtsClient[F]
      ): Kleisli[F, Context[F, _], Unit] =
        mt.local(ctx => FtsContext(cfg, fts, ctx))
    }
  }
} 

package docspell.analysis.contact

import cats.data.NonEmptyList

import docspell.common.LenientUri

case class Domain(labels: NonEmptyList[String], tld: String) {

  def asString: String =
    labels.toList.mkString(".") + tld

  def toPrimaryDomain: Domain =
    if (labels.tail.isEmpty) this
    else Domain(NonEmptyList.of(labels.last), tld)
}

object Domain {

  def domainFromUri(uri: String): Either[String, Domain] =
    LenientUri
      .parse(if (uri.contains("://")) uri else s"http://$uri")
      .flatMap(uri => uri.authority.toRight("Uri has no authoriry part"))
      .flatMap(auth => parse(auth))

  def parse(str: String): Either[String, Domain] =
    Tld
      .findTld(str)
      .map(tld => (str.dropRight(tld.length), tld))
      .map({
        case (names, tld) =>
          names.split('.').toList match {
            case Nil => Left(s"Not a domain: $str")
            case segs
                if segs.forall(label =>
                  label.trim.nonEmpty && label
                    .forall(c => c.isLetter || c.isDigit || c == '-')
                ) =>
              Right(Domain(NonEmptyList.fromListUnsafe(segs), tld))
            case _ => Left(s"Not a domain: $str")
          }
      })
      .getOrElse(Left(s"Not a domain $str"))

  def isDomain(str: String): Boolean =
    parse(str).isRight
} 

package docspell.common

import java.time.LocalDate

import cats.data.NonEmptyList
import cats.implicits._
import cats.kernel.Order

import docspell.common.MetaProposal.Candidate
import docspell.common._

import io.circe._
import io.circe.generic.semiauto._


  def flatten(s: NonEmptyList[Candidate]): NonEmptyList[Candidate] = {
    def mergeInto(
        res: NonEmptyList[Candidate],
        el: Candidate
    ): NonEmptyList[Candidate] = {
      val l = res.map(c =>
        if (c.ref.id == el.ref.id) c.copy(origin = c.origin ++ el.origin) else c
      )
      if (l == res) l :+ el
      else l
    }
    val init = NonEmptyList.of(s.head)
    s.tail.foldLeft(init)(mergeInto)
  }

  implicit val jsonDecoder: Decoder[MetaProposal] =
    deriveDecoder[MetaProposal]
  implicit val jsonEncoder: Encoder[MetaProposal] =
    deriveEncoder[MetaProposal]

} 

package docspell.common

import cats.data.NonEmptyList

import io.circe.{Decoder, Encoder}

sealed trait ItemState { self: Product =>

  final def name: String =
    productPrefix.toLowerCase

  def isValid: Boolean =
    ItemState.validStates.exists(_ == this)

  def isInvalid: Boolean =
    ItemState.invalidStates.exists(_ == this)
}

object ItemState {

  case object Premature  extends ItemState
  case object Processing extends ItemState
  case object Created    extends ItemState
  case object Confirmed  extends ItemState

  def fromString(str: String): Either[String, ItemState] =
    str.toLowerCase match {
      case "premature"  => Right(Premature)
      case "processing" => Right(Processing)
      case "created"    => Right(Created)
      case "confirmed"  => Right(Confirmed)
      case _            => Left(s"Invalid item state: $str")
    }

  val validStates: NonEmptyList[ItemState] =
    NonEmptyList.of(Created, Confirmed)

  val invalidStates: NonEmptyList[ItemState] =
    NonEmptyList.of(Premature, Processing)

  def unsafe(str: String): ItemState =
    fromString(str).fold(sys.error, identity)

  implicit val jsonDecoder: Decoder[ItemState] =
    Decoder.decodeString.emap(fromString)
  implicit val jsonEncoder: Encoder[ItemState] =
    Encoder.encodeString.contramap(_.name)
} 

package docspell.common

import cats.data.NonEmptyList
import cats.kernel.Monoid

import docspell.common.MetaProposal.Candidate

import io.circe._
import io.circe.generic.semiauto._


  def flatten(ml: Seq[MetaProposalList]): MetaProposalList = {
    val init: Map[MetaProposalType, MetaProposal] = Map.empty

    def updateMap(
        map: Map[MetaProposalType, MetaProposal],
        mp: MetaProposal
    ): Map[MetaProposalType, MetaProposal] =
      map.get(mp.proposalType) match {
        case Some(mp0) => map.updated(mp.proposalType, mp0.addIdRef(mp.values.toList))
        case None      => map.updated(mp.proposalType, mp)
      }

    val merged = ml.foldLeft(init)((map, el) => el.proposals.foldLeft(map)(updateMap))

    fromMap(merged)
  }

  implicit val jsonEncoder: Encoder[MetaProposalList] =
    deriveEncoder[MetaProposalList]
  implicit val jsonDecoder: Decoder[MetaProposalList] =
    deriveDecoder[MetaProposalList]

  implicit val metaProposalListMonoid: Monoid[MetaProposalList] =
    Monoid.instance(empty, (m0, m1) => flatten(Seq(m0, m1)))
} 

package docspell.common

import minitest._
import cats.data.NonEmptyList
import docspell.common.MetaProposal.Candidate

object MetaProposalListTest extends SimpleTestSuite {

  test("flatten retains order of candidates") {
    val cand1 = Candidate(IdRef(Ident.unsafe("123"), "name"), Set.empty)
    val mpl1 = MetaProposalList.of(
      MetaProposal(
        MetaProposalType.CorrOrg,
        NonEmptyList.of(cand1)
      )
    )
    val cand2 = Candidate(IdRef(Ident.unsafe("456"), "name"), Set.empty)
    val mpl2 = MetaProposalList.of(
      MetaProposal(
        MetaProposalType.CorrOrg,
        NonEmptyList.of(cand2)
      )
    )

    val candidates1 = MetaProposalList
      .flatten(Seq(mpl1, mpl2))
      .find(MetaProposalType.CorrOrg)
      .get
      .values
    assertEquals(candidates1.head, cand1)
    assertEquals(candidates1.tail.head, cand2)

    val candidates2 = MetaProposalList
      .flatten(Seq(mpl2, mpl1))
      .find(MetaProposalType.CorrOrg)
      .get
      .values
    assertEquals(candidates2.head, cand2)
    assertEquals(candidates2.tail.head, cand1)
  }

  test("sort by weights") {
    val cand1 = Candidate(IdRef(Ident.unsafe("123"), "name"), Set.empty, Some(0.1))
    val cand2 = Candidate(IdRef(Ident.unsafe("456"), "name"), Set.empty, Some(0.05))
    val mpl = MetaProposalList
      .of(
        MetaProposal(MetaProposalType.CorrOrg, NonEmptyList.of(cand1)),
        MetaProposal(MetaProposalType.CorrOrg, NonEmptyList.of(cand2))
      )
      .sortByWeights

    val candidates = mpl.find(MetaProposalType.CorrOrg).get.values
    assertEquals(candidates.head, cand2)
    assertEquals(candidates.tail.head, cand1)
  }

  test("sort by weights: unset is last") {
    val cand1 = Candidate(IdRef(Ident.unsafe("123"), "name"), Set.empty, Some(0.1))
    val cand2 = Candidate(IdRef(Ident.unsafe("456"), "name"), Set.empty)
    val mpl = MetaProposalList
      .of(
        MetaProposal(MetaProposalType.CorrOrg, NonEmptyList.of(cand1)),
        MetaProposal(MetaProposalType.CorrOrg, NonEmptyList.of(cand2))
      )
      .sortByWeights

    val candidates = mpl.find(MetaProposalType.CorrOrg).get.values
    assertEquals(candidates.head, cand1)
    assertEquals(candidates.tail.head, cand2)
  }
} 

package org.bykn.bosatsu

import cats.data.NonEmptyList
import cats.effect.IO
import java.nio.file.Path
import java.io.PrintWriter
import org.typelevel.paiges.Doc

object CodeGenWrite {
  @annotation.tailrec
  final def toPath(root: Path, pn: PackageName): Path =
    pn.parts match {
      case NonEmptyList(h, Nil) => root.resolve(h).resolve("Values.java")
      case NonEmptyList(h0, h1 :: tail) =>
        toPath(root.resolve(h0), PackageName(NonEmptyList(h1, tail)))
    }

  def writeDoc(p: Path, d: Doc): IO[Unit] =
    IO {
      Option(p.getParent).foreach(_.toFile.mkdirs)
      val pw = new PrintWriter(p.toFile, "UTF-8")
      try d.renderStream(80).foreach(pw.print(_))
      finally {
        pw.close
      }
    }
} 

package org.bykn.bosatsu

import cats.Applicative
import cats.data.NonEmptyList
import cats.implicits._
import org.bykn.bosatsu.rankn.Type
import org.bykn.bosatsu.Identifier.Constructor

object TypeRefConverter {
  
  def apply[F[_]: Applicative](t: TypeRef)(nameToType: Constructor => F[Type.Const]): F[Type] = {
    def toType(t: TypeRef): F[Type] = apply(t)(nameToType)

    import Type._
    import TypeRef._

    t match {
      case TypeVar(v) => Applicative[F].pure(TyVar(Type.Var.Bound(v)))
      case TypeName(n) => nameToType(n.ident).map(TyConst(_))
      case TypeArrow(a, b) => (toType(a), toType(b)).mapN(Fun(_, _))
      case TypeApply(a, bs) =>
        @annotation.tailrec
        def toType1(fn: Type, args: NonEmptyList[Type]): Type =
          args match {
            case NonEmptyList(a0, Nil) => TyApply(fn,a0)
            case NonEmptyList(a0, a1 :: as) =>
              toType1(TyApply(fn, a0), NonEmptyList(a1, as))
          }
        (toType(a), bs.traverse(toType)).mapN(toType1(_, _))
      case TypeLambda(pars0, TypeLambda(pars1, e)) =>
        // we normalize to lifting all the foralls to the outside
        toType(TypeLambda(pars0 ::: pars1, e))
      case TypeLambda(pars, e) =>
        toType(e).map { te =>
          Type.forAll(pars.map { case TypeVar(v) => Type.Var.Bound(v) }.toList, te)
        }
      case TypeTuple(ts) =>
        ts.traverse(toType).map(Type.Tuple(_))
    }
  }
} 

package org.bykn.bosatsu

import cats.Order
import cats.data.NonEmptyList
import cats.implicits._
import fastparse.all._
import org.typelevel.paiges.{Doc, Document}
import Parser.upperIdent

case class PackageName(parts: NonEmptyList[String]) {
  lazy val asString: String = parts.toList.mkString("/")
}

object PackageName {

  def parts(first: String, rest: String*): PackageName =
    PackageName(NonEmptyList.of(first, rest :_*))

  implicit val document: Document[PackageName] =
    Document.instance[PackageName] { pn => Doc.text(pn.asString) }

  implicit val parser: P[PackageName] =
    P(upperIdent ~ ("/" ~ upperIdent).rep()).map { case (head, tail) =>
      PackageName(NonEmptyList(head, tail.toList))
    }

  def parse(s: String): Option[PackageName] =
    parser.parse(s) match {
      case Parsed.Success(pn, idx) if idx == s.length => Some(pn)
      case _ => None
    }

  implicit val order: Order[PackageName] =
    Order[NonEmptyList[String]].contramap[PackageName](_.parts)

  implicit val packageNameOrdering: Ordering[PackageName] =
    order.toOrdering

  val PredefName: PackageName =
    PackageName(NonEmptyList.of("Bosatsu", "Predef"))
} 

package org.bykn.bosatsu

import cats.{Foldable, Functor}
import cats.data.NonEmptyList
import cats.implicits._
import fastparse.all._
import org.typelevel.paiges.{Doc, Document}

import Parser.{spaces, maybeSpace, Combinators}

sealed abstract class ImportedName[+T] {
  def originalName: Identifier
  def localName: Identifier
  def tag: T
  def isRenamed: Boolean = originalName != localName

  def map[U](fn: T => U): ImportedName[U] =
    this match {
      case [email protected](n, t) =>
        ImportedName.OriginalName(n, fn(t))
      case [email protected](o, l, t) =>
        ImportedName.Renamed(o, l, fn(t))
    }

  def traverse[F[_], U](fn: T => F[U])(implicit F: Functor[F]): F[ImportedName[U]] =
    this match {
      case [email protected](n, t) =>
        F.map(fn(t))(ImportedName.OriginalName(n, _))
      case [email protected](o, l, t) =>
        F.map(fn(t))(ImportedName.Renamed(o, l, _))
    }
}

object ImportedName {
  case class OriginalName[T](originalName: Identifier, tag: T) extends ImportedName[T] {
    def localName = originalName
  }
  case class Renamed[T](originalName: Identifier, localName: Identifier, tag: T) extends ImportedName[T]

  implicit val document: Document[ImportedName[Unit]] =
    Document.instance[ImportedName[Unit]] {
      case ImportedName.OriginalName(nm, _) => Document[Identifier].document(nm)
      case ImportedName.Renamed(from, to, _) =>
        Document[Identifier].document(from) + Doc.text(" as ") +
          Document[Identifier].document(to)
    }

  val parser: P[ImportedName[Unit]] = {
    def basedOn(of: P[Identifier]): P[ImportedName[Unit]] =
      P(of ~ (spaces ~ "as" ~ spaces ~/ of).?).map {
        case (from, Some(to)) => ImportedName.Renamed(from, to, ())
        case (orig, None) => ImportedName.OriginalName(orig, ())
      }

    basedOn(Identifier.bindableParser) | basedOn(Identifier.consParser)
  }
}

case class Import[A, B](pack: A, items: NonEmptyList[ImportedName[B]])

object Import {
  implicit val document: Document[Import[PackageName, Unit]] =
    Document.instance[Import[PackageName, Unit]] { case Import(pname, items) =>
      Doc.text("import ") + Document[PackageName].document(pname) + Doc.space +
        // TODO: use paiges to pack this in nicely using .group or something
        Doc.char('[') + Doc.intercalate(Doc.text(", "), items.toList.map(Document[ImportedName[Unit]].document _)) + Doc.char(']')
    }

  val parser: P[Import[PackageName, Unit]] = {
    P("import" ~ spaces ~/ PackageName.parser ~ maybeSpace ~
      ImportedName.parser.nonEmptyListSyntax).map { case (pname, imported) =>
        Import(pname, imported)
      }
  }

  
case class ImportMap[A, B](toMap: Map[Identifier, (A, ImportedName[B])]) {
  def apply(name: Identifier): Option[(A, ImportedName[B])] =
    toMap.get(name)

  def +(that: (A, ImportedName[B])): ImportMap[A, B] =
    ImportMap(toMap.updated(that._2.localName, that))
}

object ImportMap {
  def empty[A, B]: ImportMap[A, B] = ImportMap(Map.empty)
  // Return the list of collisions in local names along with a map
  // with the last name overwriting the import
  def fromImports[A, B](is: List[Import[A, B]]): (List[(A, ImportedName[B])], ImportMap[A, B]) =
    is.iterator
      .flatMap { case Import(p, is) => is.toList.iterator.map((p, _)) }
      .foldLeft((List.empty[(A, ImportedName[B])], ImportMap.empty[A, B])) {
        case ((dups, imap), pim@(pack, im)) =>
          val dups1 = imap(im.localName) match {
            case Some(nm) => nm :: dups
            case None => dups
          }

          (dups1, imap + pim)
        }
} 

package org.bykn.bosatsu.graph

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._

case class Tree[+A](item: A, children: List[Tree[A]])

object Tree {

  def neighborsFn[A](t: Tree[A]): A => List[A] = {
    def toMap(t: Tree[A]): Map[A, Tree[A]] =
      Map(t.item -> t) ++ (t.children.flatMap(toMap(_)))

    val mapToTree: Map[A, Tree[A]] = toMap(t)


    { a: A => mapToTree.get(a).fold(List.empty[A])(_.children.map(_.item)) }
  }

  
  def dagToTree[A](node: A)(nfn: A => List[A]): ValidatedNel[NonEmptyList[A], Tree[A]] = {
    def treeOf(path: NonEmptyList[A], visited: Set[A]): ValidatedNel[NonEmptyList[A], Tree[A]] = {
      val children = nfn(path.head)
      def assumeValid(children: List[A]): ValidatedNel[NonEmptyList[A], Tree[A]] =
        children.traverse { a =>
          // we grow the path out here
          treeOf(a :: path, visited + a)
        }
        .map(Tree(path.head, _))

      NonEmptyList.fromList(children.filter(visited)) match {
        case Some(loops) =>
          val paths = loops.map(_ :: path)
          val invalid = Validated.invalid(paths)
          // also search all the valid cases
          invalid *> assumeValid(children.filterNot(visited))
        case None => assumeValid(children)
      }
    }
    treeOf(NonEmptyList(node, Nil), Set(node))
      .leftMap { nelnel =>
        // remove depulicate paths
        val withSet = nelnel.map { nel => (nel, nel.toList.toSet) }
        distinctBy(withSet)(_._2).map(_._1)
      }
  }

  def distinctBy[A, B](nel: NonEmptyList[A])(fn: A => B): NonEmptyList[A] = {
    @annotation.tailrec
    def remove(seen: Set[B], items: List[A], acc: List[A]): List[A] =
      items match {
        case Nil => acc.reverse
        case h :: t =>
          val b = fn(h)
          if (seen(b)) remove(seen, t, acc)
          else remove(seen + b, t, h :: acc)
      }

    NonEmptyList(nel.head, remove(Set(fn(nel.head)), nel.tail, Nil))
  }

  def distinctBy[A, B](nel: List[A])(fn: A => B): List[A] =
    NonEmptyList.fromList(nel) match {
      case None => Nil
      case Some(nel) => distinctBy(nel)(fn).toList
    }
} 

package org.bykn.bosatsu

import Parser.{ Combinators, maybeSpace, spaces }
import cats.Applicative
import cats.data.NonEmptyList
import cats.implicits._
import fastparse.all._
import org.bykn.fastparse_cats.StringInstances._
import org.typelevel.paiges.{ Doc, Document }

import Identifier.{Bindable, Constructor}

case class DefStatement[A, B](
  name: Bindable,
  args: List[A],
  retType: Option[TypeRef], result: B) {

  
    def parser[A, B](argParser: P[A], resultTParser: P[B]): P[DefStatement[A, B]] = {
      val args = argParser.parensLines1
      val result = P("->" ~/ maybeSpace ~ TypeRef.parser).?
      P("def" ~ spaces ~/ Identifier.bindableParser ~ args.? ~ maybeSpace ~
        result ~ maybeSpace ~ ":" ~/ resultTParser)
        .map {
          case (name, optArgs, resType, res) =>
            val args = optArgs match {
              case None => Nil
              case Some(ne) => ne.toList
            }
            DefStatement(name, args, resType, res)
        }
    }
} 

package com.azavea.franklin.extensions.validation

import cats.data.NonEmptyList
import cats.data.Validated.{Invalid, Valid}
import cats.kernel.Semigroup
import com.azavea.stac4s.extensions.ItemAssetExtension
import com.azavea.stac4s.extensions.{ExtensionResult, ItemExtension, LinkExtension}
import eu.timepit.refined.types.string.NonEmptyString
import io.circe._
import io.circe.refined._
import io.circe.syntax._

final case class ValidationExtension(
    attemptedExtensions: NonEmptyList[NonEmptyString],
    errors: List[NonEmptyString]
)

object ValidationExtension {

  implicit val decValidationExtension: Decoder[ValidationExtension] = Decoder.forProduct2(
    "validation:attemptedExtensions",
    "validation:errors"
  )((extensions: NonEmptyList[NonEmptyString], errors: List[NonEmptyString]) =>
    ValidationExtension(extensions, errors)
  )

  implicit val encValidationExtension: Encoder.AsObject[ValidationExtension] = Encoder
    .AsObject[Map[String, Json]]
    .contramapObject((validationExtensionFields: ValidationExtension) =>
      Map(
        "validation:attemptedExtensions" -> validationExtensionFields.attemptedExtensions.asJson,
        "validation:errors"              -> validationExtensionFields.errors.asJson
      )
    )

  implicit val validationExtensionItemExtension: ItemExtension[ValidationExtension] =
    ItemExtension.instance

  implicit val validationExtensionLinkExtension: LinkExtension[ValidationExtension] =
    LinkExtension.instance

  implicit val validationExtensionAssetExtension: ItemAssetExtension[ValidationExtension] =
    ItemAssetExtension.instance

  implicit val semigroupValidationExtension: Semigroup[ValidationExtension] =
    new Semigroup[ValidationExtension] {

      def combine(x: ValidationExtension, y: ValidationExtension): ValidationExtension = {
        ValidationExtension(
          x.attemptedExtensions.concat(y.attemptedExtensions.toList),
          x.errors ++ y.errors
        )
      }
    }

  def success(name: NonEmptyString) = ValidationExtension(
    NonEmptyList.of(name),
    Nil
  )

  def failure(name: NonEmptyString, errors: List[DecodingFailure]) =
    ValidationExtension(NonEmptyList.of(name), errors map { (err: DecodingFailure) =>
      NonEmptyString.from(CursorOp.opsToPath(err.history))
    } collect {
      case Right(v) => v
    })

  def fromResult[T](result: ExtensionResult[T], name: NonEmptyString) = result match {
    case Invalid(errs) =>
      failure(name, errs collect {
        case e: DecodingFailure => e
      })
    case Valid(_) =>
      success(name)
  }
} 

package com.github.johnynek.bazel_deps

import cats.data.{ NonEmptyList, Validated, ValidatedNel }
import cats.Foldable
import cats.implicits._
import io.circe.jawn.JawnParser
import java.io.{ File, PrintWriter }
import scala.util.{ Failure, Success }
import java.nio.file.Path

object MergeDeps {
  private def load(f: Path): ValidatedNel[String, Model] =
    FormatDeps.readModel(f.toFile) match {
      case Right(m) => Validated.valid(m)
      case Left(err) => Validated.invalidNel(err)
    }

  def fail(errs: NonEmptyList[String]): Nothing = {
    errs.toList.foreach(System.err.println)
    System.exit(1)
    sys.error("unreachable")
  }

  def apply(models: NonEmptyList[Path], out: Option[Path]): Unit = {

    type A[T] = ValidatedNel[String, T]
    val mod = models.traverse[A, Model](load).toEither.right.flatMap {
      Model.combine(_)
    }

    mod match {
      case Left(errs) => fail(errs)
      case Right(m) =>
        val stream = m.toDoc.renderStream(100)
        out match {
          case None => stream.foreach(System.out.print)
          case Some(path) =>
            val pw = new PrintWriter(path.toFile)
            stream.foreach(pw.print(_))
            pw.flush
            pw.close
        }
      }
  }

  def addDep(model: Path, lang: Language, coords: NonEmptyList[MavenCoordinate]): Unit =
    load(model) match {
      case Validated.Invalid(errs) => fail(errs)
      case Validated.Valid(m) =>
        val realLang = m.getOptions.replaceLang(lang)
        val deps = coords.map(realLang.unmangle(_).toDependencies(realLang))

        def combine(d1: Dependencies, d2: Dependencies): Either[NonEmptyList[String], Dependencies] =
          Dependencies.combine(m.getOptions.getVersionConflictPolicy, d1, d2).toEither

        type E[T] = Either[NonEmptyList[String], T]
        Foldable[NonEmptyList].foldM[E, Dependencies, Dependencies](deps, m.dependencies)(combine) match {
          case Left(errs) => fail(errs)
          case Right(resDep) =>
            val stream = m.copy(dependencies = resDep).toDoc.renderStream(100)
            val pw = new PrintWriter(model.toFile)
            stream.foreach(pw.print(_))
            pw.flush
            pw.close
        }
  }
} 

package cron4s

import cats.Show
import cats.data.NonEmptyList
import cats.syntax.show._


sealed abstract class Error(description: String) extends Exception(description)

object Error {
  implicit val errorShow: Show[Error] = Show.show(_.getMessage)
}

final case class ParseFailed(msg: String, found: String, position: Int)
    extends Error(s"$msg at position $position but found '$found'")

sealed trait ValidationError
object ValidationError {
  implicit val validationErrorShow: Show[ValidationError] = Show.show {
    case e: InvalidField            => e.show
    case e: InvalidFieldCombination => e.show
  }
}

final case class InvalidCron(reason: NonEmptyList[ValidationError])
    extends Error(reason.toList.map(_.show).mkString(", "))

final case class InvalidField(field: CronField, msg: String) extends ValidationError
object InvalidField {
  implicit val invalidFieldShow: Show[InvalidField] = Show.show { err =>
    s"${err.field}: ${err.msg}"
  }
}

final case class InvalidFieldCombination(msg: String) extends ValidationError
object InvalidFieldCombination {
  implicit val invalidFieldCombinationShow: Show[InvalidFieldCombination] =
    Show.show(_.msg)
} 

package cron4s

import cats.data.NonEmptyList


package object validation {
  def validateCron(expr: CronExpr): Either[InvalidCron, CronExpr] = {
    val dayFieldError = validateDayFields(expr)
    val fieldErrors   = expr.raw.map(ops.validate).toList.flatten

    val allErrors =
      dayFieldError.fold[List[ValidationError]](fieldErrors)(_ :: fieldErrors)

    NonEmptyList
      .fromList(allErrors)
      .map(errs => Left(InvalidCron(errs)))
      .getOrElse(Right(expr))
  }

  private def validateDayFields(expr: CronExpr) = {
    val dayOfMonth = expr.field[CronField.DayOfMonth].toString
    val dayOfWeek  = expr.field[CronField.DayOfWeek].toString

    if (dayOfMonth == dayOfWeek) {
      Some(
        InvalidFieldCombination(
          s"Fields ${CronField.DayOfMonth} and ${CronField.DayOfWeek} can't both have the expression: $dayOfMonth"
        )
      )
    } else if ((dayOfMonth != "?" && dayOfWeek == "?") || (dayOfMonth == "?" && dayOfWeek != "?")) {
      None
    } else
      Some(
        InvalidFieldCombination(
          s"Either ${CronField.DayOfMonth} and ${CronField.DayOfWeek} must have a ? expression"
        )
      )
  }
} 

package coursier.install

import argonaut.{DecodeJson, EncodeJson, Parse}
import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import coursier.parse.RepositoryParser
import dataclass.data


@data class RawSource(
  repositories: List[String],
  channel: String,
  id: String
) {
  def source: ValidatedNel[String, Source] = {

    import RawAppDescriptor.validationNelToCats

    val repositoriesV = validationNelToCats(RepositoryParser.repositories(repositories))

    val channelV = Validated.fromEither(
      Channel.parse(channel)
        .left.map(NonEmptyList.one)
    )

    (repositoriesV, channelV).mapN {
      (repositories, channel) =>
        Source(
          repositories,
          channel,
          id
        )
    }
  }
  def repr: String =
    RawSource.encoder.encode(this).nospaces
}

object RawSource {

  import argonaut.ArgonautShapeless._

  implicit val encoder = EncodeJson.of[RawSource]
  implicit val decoder = DecodeJson.of[RawSource]

  def parse(input: String): Either[String, RawSource] =
    Parse.decodeEither(input)(decoder)

} 

package coursier.cli.params

import java.io.File
import java.nio.charset.StandardCharsets
import java.nio.file.Files

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import coursier.{Repositories, moduleString}
import coursier.cli.install.SharedChannelParams
import coursier.cli.options.RepositoryOptions
import coursier.core.Repository
import coursier.install.Channel
import coursier.ivy.IvyRepository
import coursier.maven.MavenRepository
import coursier.parse.RepositoryParser

final case class RepositoryParams(
  repositories: Seq[Repository],
  channels: SharedChannelParams
)

object RepositoryParams {

  def apply(options: RepositoryOptions, hasSbtPlugins: Boolean = false): ValidatedNel[String, RepositoryParams] = {

    val repositoriesV = Validated.fromEither(
      RepositoryParser.repositories(options.repository)
        .either
        .left
        .map {
          case h :: t => NonEmptyList(h, t)
        }
    )

    val channelsV = SharedChannelParams(options.channelOptions)

    (repositoriesV, channelsV).mapN {
      (repos0, channels) =>

        // preprend defaults
        val defaults =
          if (options.noDefault) Nil
          else {
            val extra =
              if (hasSbtPlugins) Seq(Repositories.sbtPlugin("releases"))
              else Nil
            coursier.Resolve.defaultRepositories ++ extra
          }
        var repos = defaults ++ repos0

        // take sbtPluginHack into account
        repos = repos.map {
          case m: MavenRepository => m.withSbtAttrStub(options.sbtPluginHack)
          case other => other
        }

        // take dropInfoAttr into account
        if (options.dropInfoAttr)
          repos = repos.map {
            case m: IvyRepository => m.withDropInfoAttributes(true)
            case other => other
          }

        RepositoryParams(
          repos,
          channels
        )
    }
  }
} 

package coursier.cli.publish.params

import java.nio.file.{Files, Path, Paths}

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import coursier.cli.publish.options.SinglePackageOptions
import coursier.core.{Classifier, Extension}

final case class SinglePackageParams(
  jarOpt: Option[Path],
  pomOpt: Option[Path],
  artifacts: Seq[(Classifier, Extension, Path)],
  `package`: Boolean
)

object SinglePackageParams {

  private def q = "\""

  def apply(options: SinglePackageOptions): ValidatedNel[String, SinglePackageParams] = {

    // FIXME This does some I/O (not reflected in return type)

    def fileExtensionV(path: String): ValidatedNel[String, (Path, String)] =
      fileV(path).withEither(_.flatMap { p =>
        val name = p.getFileName.toString
        val idx = name.lastIndexOf('.')
        if (idx < 0)
          Left(NonEmptyList.one(s"$path has no extension, specify one by passing it with classifier:extension:$path"))
        else {
          val ext = name.drop(idx + 1)
          if (ext.isEmpty)
            Left(NonEmptyList.one(s"$path extension is empty, specify one by passing it with classifier:extension:$path"))
          else
            Right((p, ext))
        }
      })

    def fileV(path: String): ValidatedNel[String, Path] = {
      val p = Paths.get(path)
      if (!Files.exists(p))
        Validated.invalidNel(s"not found: $path")
      else if (!Files.isRegularFile(p))
        Validated.invalidNel(s"not a regular file: $path")
      else
        Validated.validNel(p)
    }

    def fileOptV(pathOpt: Option[String]): ValidatedNel[String, Option[Path]] =
      pathOpt match {
        case None =>
          Validated.validNel(None)
        case Some(path) =>
          fileV(path).map(Some(_))
      }

    val jarOptV = fileOptV(options.jar)
    val pomOptV = fileOptV(options.pom)

    val artifactsV = options.artifact.traverse { s =>
      s.split(":", 3) match {
        case Array(strClassifier, strExtension, path) =>
          fileV(path).map((Classifier(strClassifier), Extension(strExtension), _))
        case Array(strClassifier, path) =>
          fileExtensionV(path).map {
            case (p, ext) =>
              (Classifier(strClassifier), Extension(ext), p)
          }
        case _ =>
          Validated.invalidNel(s"Malformed artifact argument: $s (expected: ${q}classifier:/path/to/artifact$q)")
      }
    }

    val packageV = options.`package` match {
      case Some(true) =>
        Validated.validNel(true)
      case Some(false) =>
        if (options.jar.nonEmpty || options.pom.nonEmpty || options.artifact.nonEmpty)
          Validated.invalidNel("Cannot specify --package=false along with --pom or --jar or --artifact")
        else
          Validated.validNel(false)
      case None =>
        val p = options.jar.nonEmpty || options.pom.nonEmpty || options.artifact.nonEmpty
        Validated.validNel(p)
    }

    (jarOptV, pomOptV, artifactsV, packageV).mapN {
      (jarOpt, pomOpt, artifacts, package0) =>
        SinglePackageParams(
          jarOpt,
          pomOpt,
          artifacts,
          package0
        )
    }
  }
} 

package coursier.cli.install

import java.io.File
import java.nio.charset.StandardCharsets
import java.nio.file.Files

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import coursier.cli.jvm.SharedJavaParams
import coursier.cli.params.{CacheParams, EnvParams, OutputParams}
import coursier.install.Channel

final case class InstallParams(
  cache: CacheParams,
  output: OutputParams,
  shared: SharedInstallParams,
  sharedChannel: SharedChannelParams,
  sharedJava: SharedJavaParams,
  env: EnvParams,
  addChannels: Seq[Channel],
  installChannels: Seq[String],
  force: Boolean
) {
  lazy val channels: Seq[Channel] =
    (sharedChannel.channels ++ addChannels).distinct
}

object InstallParams {

  def apply(options: InstallOptions, anyArg: Boolean): ValidatedNel[String, InstallParams] = {

    val cacheParamsV = options.cacheOptions.params(None)
    val outputV = OutputParams(options.outputOptions)

    val sharedV = SharedInstallParams(options.sharedInstallOptions)

    val sharedChannelV = SharedChannelParams(options.sharedChannelOptions)
    val sharedJavaV = SharedJavaParams(options.sharedJavaOptions)

    val envV = EnvParams(options.envOptions)

    val addChannelsV = options.addChannel.traverse { s =>
      val e = Channel.parse(s)
        .left.map(NonEmptyList.one)
        .map(c => (s, c))
      Validated.fromEither(e)
    }

    val force = options.force

    val checkNeedsChannelsV =
      if (anyArg && sharedChannelV.toOption.exists(_.channels.isEmpty) && addChannelsV.toOption.exists(_.isEmpty))
        Validated.invalidNel(s"Error: no channels specified")
      else
        Validated.validNel(())

    val flags = Seq(
      options.addChannel.nonEmpty,
      envV.toOption.fold(false)(_.anyFlag)
    )
    val flagsV =
      if (flags.count(identity) > 1)
        Validated.invalidNel("Error: can only specify one of --add-channel, --env, --setup.")
      else
        Validated.validNel(())

    val checkArgsV =
      if (anyArg && flags.exists(identity))
        Validated.invalidNel(s"Error: unexpected arguments passed along --add-channel, --env, or --setup.")
      else
        Validated.validNel(())

    (cacheParamsV, outputV, sharedV, sharedChannelV, sharedJavaV, envV, addChannelsV, checkNeedsChannelsV, flagsV, checkArgsV).mapN {
      (cacheParams, output, shared, sharedChannel, sharedJava, env, addChannels, _, _, _) =>
        InstallParams(
          cacheParams,
          output,
          shared,
          sharedChannel,
          sharedJava,
          env,
          addChannels.map(_._2),
          addChannels.map(_._1),
          force
        )
    }
  }
} 

package coursier.cli.install

import java.io.File
import java.nio.charset.StandardCharsets
import java.nio.file.Files

import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import coursier.install.Channel
import coursier.install.Channels

final case class SharedChannelParams(
  channels: Seq[Channel]
)

object SharedChannelParams {
  def apply(options: SharedChannelOptions): ValidatedNel[String, SharedChannelParams] = {

    val channelsV = options
      .channel
      .traverse { s =>
        val e = Channel.parse(s)
          .left.map(NonEmptyList.one)
        Validated.fromEither(e)
      }

    val defaultChannels =
      if (options.defaultChannels) Channels.defaultChannels
      else Nil

    val contribChannels =
      if (options.contrib) Channels.contribChannels
      else Nil

    val fileChannelsV =
      if (options.fileChannels) {
        val configDir = coursier.paths.CoursierPaths.configDirectory()
        val channelDir = new File(configDir, "channels")
        val files = Option(channelDir.listFiles())
          .getOrElse(Array.empty[File])
          .filter(f => !f.getName.startsWith("."))
        val rawChannels = files.toList.flatMap { f =>
          val b = Files.readAllBytes(f.toPath)
          val s = new String(b, StandardCharsets.UTF_8)
          s.linesIterator.map(_.trim).filter(_.nonEmpty).toSeq
        }
        rawChannels.traverse { s =>
          val e = Channel.parse(s)
            .left.map(NonEmptyList.one)
          Validated.fromEither(e)
        }
      } else
        Validated.validNel(Nil)

    (channelsV, fileChannelsV).mapN {
      (channels, fileChannels) =>
        SharedChannelParams(
          (channels ++ fileChannels ++ defaultChannels ++ contribChannels).distinct
        )
    }
  }
} 

package coursier.cli.install

import java.nio.file.{Path, Paths}

import caseapp.Tag
import cats.data.{NonEmptyList, Validated, ValidatedNel}
import cats.implicits._
import coursier.cache.{Cache, CacheLogger}
import coursier.cli.params.OutputParams
import coursier.core.Repository
import coursier.install.{GraalvmParams, InstallDir}
import coursier.parse.RepositoryParser
import coursier.util.Task

final case class SharedInstallParams(
  repositories: Seq[Repository],
  dir: Path,
  graalvmParamsOpt: Option[GraalvmParams] = None,
  onlyPrebuilt: Boolean,
  platformOpt: Option[String],
  preferPrebuilt: Boolean
) {

  def installDir(cache: Cache[Task]): InstallDir =
    InstallDir(dir, cache)
      .withGraalvmParamsOpt(graalvmParamsOpt)
      .withCoursierRepositories(repositories)
      .withOnlyPrebuilt(onlyPrebuilt)
      .withPlatform(platformOpt)
      .withPreferPrebuilt(preferPrebuilt)
}

object SharedInstallParams {

  lazy val defaultDir = InstallDir.defaultDir

  private[install] implicit def validationNelToCats[L, R](v: coursier.util.ValidationNel[L, R]): ValidatedNel[L, R] =
    v.either match {
      case Left(h :: t) => Validated.invalid(NonEmptyList.of(h, t: _*))
      case Right(r) => Validated.validNel(r)
    }

  def apply(options: SharedInstallOptions): ValidatedNel[String, SharedInstallParams] = {

    val repositoriesV = validationNelToCats(RepositoryParser.repositories(options.repository))

    val defaultRepositories =
      if (options.defaultRepositories)
        coursier.Resolve.defaultRepositories
      else
        Nil

    val dir = options.installDir.filter(_.nonEmpty) match {
      case Some(d) => Paths.get(d)
      case None => defaultDir
    }

    val graalvmParams = GraalvmParams(
      options.graalvmDefaultVersion.filter(_.nonEmpty),
      options.graalvmOption
    )

    val onlyPrebuilt = options.onlyPrebuilt

    val platformOpt = options.installPlatform.orElse(InstallDir.platform())

    val preferPrebuilt = options.installPreferPrebuilt

    repositoriesV.map { repositories =>
      SharedInstallParams(
        defaultRepositories ++ repositories,
        dir,
        Some(graalvmParams),
        onlyPrebuilt,
        platformOpt,
        preferPrebuilt
      )
    }
  }
} 

package ru.pavkin.booking.booking.serialization

import aecor.data.Enriched
import aecor.journal.postgres.PostgresEventJournal
import aecor.journal.postgres.PostgresEventJournal.Serializer.TypeHint
import cats.data.NonEmptyList
import enumeratum.EnumEntry
import ru.pavkin.booking.booking.entity._
import ru.pavkin.booking.booking.protobuf.msg
import enumeratum._
import cats.syntax.either._

import scala.collection.immutable

object BookingEventSerializer
    extends PostgresEventJournal.Serializer[Enriched[EventMetadata, BookingEvent]] {

  sealed trait Hint extends EnumEntry
  object Hint extends Enum[Hint] {
    case object AA extends Hint
    case object AB extends Hint
    case object AC extends Hint
    case object AD extends Hint
    case object AE extends Hint
    case object AF extends Hint
    case object AG extends Hint
    def values: immutable.IndexedSeq[Hint] = findValues
  }

  import Hint._

  def serialize(a: Enriched[EventMetadata, BookingEvent]): (TypeHint, Array[Byte]) = a match {
    case Enriched(m, BookingPlaced(clientId, concertId, seats)) =>
      AA.entryName -> msg.BookingPlaced(clientId, concertId, seats.toList, m.timestamp).toByteArray
    case Enriched(m, BookingConfirmed(tickets, expiresAt)) =>
      AB.entryName -> msg.BookingConfirmed(tickets.toList, expiresAt, m.timestamp).toByteArray
    case Enriched(m, BookingDenied(reason)) =>
      AC.entryName -> msg.BookingDenied(reason, m.timestamp).toByteArray
    case Enriched(m, BookingCancelled(reason)) =>
      AD.entryName -> msg.BookingCancelled(reason, m.timestamp).toByteArray
    case Enriched(m, BookingExpired) =>
      AE.entryName -> msg.BookingExpired(m.timestamp).toByteArray
    case Enriched(m, BookingPaid(paymentId)) =>
      AF.entryName -> msg.BookingPaid(paymentId, m.timestamp).toByteArray
    case Enriched(m, BookingSettled) =>
      AG.entryName -> msg.BookingSettled(m.timestamp).toByteArray
  }

  def deserialize(typeHint: TypeHint,
                  bytes: Array[Byte]): Either[Throwable, Enriched[EventMetadata, BookingEvent]] =
    Either.catchNonFatal(Hint.withName(typeHint) match {

      case Hint.AA =>
        val raw = msg.BookingPlaced.parseFrom(bytes)
        Enriched(
          EventMetadata(raw.timestamp),
          BookingPlaced(raw.clientId, raw.concertId, NonEmptyList.fromListUnsafe(raw.seats.toList))
        )

      case Hint.AB =>
        val raw = msg.BookingConfirmed.parseFrom(bytes)
        Enriched(
          EventMetadata(raw.timestamp),
          BookingConfirmed(NonEmptyList.fromListUnsafe(raw.tickets.toList), raw.expiresAt)
        )

      case Hint.AC =>
        val raw = msg.BookingDenied.parseFrom(bytes)
        Enriched(EventMetadata(raw.timestamp), BookingDenied(raw.reason))

      case Hint.AD =>
        val raw = msg.BookingCancelled.parseFrom(bytes)
        Enriched(EventMetadata(raw.timestamp), BookingCancelled(raw.reason))

      case Hint.AE =>
        val raw = msg.BookingExpired.parseFrom(bytes)
        Enriched(EventMetadata(raw.timestamp), BookingExpired)

      case Hint.AF =>
        val raw = msg.BookingPaid.parseFrom(bytes)
        Enriched(EventMetadata(raw.timestamp), BookingPaid(raw.paymentId))

      case Hint.AG =>
        val raw = msg.BookingSettled.parseFrom(bytes)
        Enriched(EventMetadata(raw.timestamp), BookingSettled)

    })
} 

package ru.pavkin.booking.booking.entity

import java.time.Instant

import aecor.data.Folded
import cats.data.NonEmptyList
import ru.pavkin.booking.common.models._
import aecor.data.Folded.syntax._

case class BookingState(clientId: ClientId,
                        concertId: ConcertId,
                        seats: NonEmptyList[Seat],
                        tickets: Option[NonEmptyList[Ticket]],
                        status: BookingStatus,
                        expiresAt: Option[Instant],
                        paymentId: Option[PaymentId]) {

  def handleEvent(e: BookingEvent): Folded[BookingState] = e match {
    case _: BookingPlaced => impossible
    case e: BookingConfirmed =>
      copy(tickets = Some(e.tickets), expiresAt = e.expiresAt, status = BookingStatus.Confirmed).next
    case _: BookingDenied | _: BookingCancelled => copy(status = BookingStatus.Canceled).next
    case BookingExpired                         => copy(status = BookingStatus.Canceled).next
    case e: BookingPaid                         => copy(paymentId = Some(e.paymentId)).next
    case BookingSettled                         => copy(status = BookingStatus.Settled).next
  }

}

object BookingState {

  def init(e: BookingEvent): Folded[BookingState] = e match {
    case e: BookingPlaced =>
      BookingState(
        e.clientId,
        e.concertId,
        e.seats,
        None,
        BookingStatus.AwaitingConfirmation,
        None,
        None
      ).next
    case _ => impossible
  }
} 

package ru.pavkin.booking.booking.entity

import java.time.Instant

import aecor.MonadActionReject
import aecor.data._
import cats.Monad
import cats.data.EitherT._
import cats.data.NonEmptyList
import cats.syntax.all._
import ru.pavkin.booking.common.models.BookingStatus._
import ru.pavkin.booking.common.models._

// Just an example, isn't uses
class EventsourcedBookingWithoutExpiration[F[_]](
  implicit F: MonadActionReject[F, Option[BookingState], BookingEvent, BookingCommandRejection]
) extends Booking[F] {

  import F._

  val ignore: F[Unit] = unit

  def place(client: ClientId, concert: ConcertId, seats: NonEmptyList[Seat]): F[Unit] =
    read.flatMap {
      case Some(_) => reject(BookingAlreadyExists)
      case None =>
        if (seats.distinct =!= seats) reject(DuplicateSeats)
        else if (seats.size > 10) reject(TooManySeats)
        else append(BookingPlaced(client, concert, seats))
    }

  def confirm(tickets: NonEmptyList[Ticket], expiresAt: Option[Instant]): F[Unit] =
    status.flatMap {
      case AwaitingConfirmation =>
        append(BookingConfirmed(tickets, null)) >>
          whenA(tickets.foldMap(_.price).amount <= 0)(append(BookingSettled))

      case Confirmed | Settled => ignore
      case Denied              => reject(BookingIsDenied)
      case Canceled            => reject(BookingIsAlreadyCanceled)
    }

  def expire: F[Unit] = ???

  def deny(reason: String): F[Unit] =
    status.flatMap {
      case AwaitingConfirmation =>
        append(BookingDenied(reason))
      case Denied              => ignore
      case Confirmed | Settled => reject(BookingIsAlreadyConfirmed)
      case Canceled            => reject(BookingIsAlreadyCanceled)
    }

  def cancel(reason: String): F[Unit] =
    status.flatMap {
      case AwaitingConfirmation | Confirmed =>
        append(BookingCancelled(reason))
      case Canceled | Denied => ignore
      case Settled           => reject(BookingIsAlreadySettled)
    }

  def receivePayment(paymentId: PaymentId): F[Unit] =
    status.flatMap {
      case AwaitingConfirmation        => reject(BookingIsNotConfirmed)
      case Canceled | Denied | Settled => reject(BookingIsAlreadySettled)
      case Confirmed                   => append(BookingPaid(paymentId)) >> append(BookingSettled)
    }

  def status: F[BookingStatus] = read.flatMap {
    case Some(s) => pure(s.status)
    case _       => reject(BookingNotFound)
  }

  def tickets: F[Option[NonEmptyList[Ticket]]] = read.map(_.flatMap(_.tickets))
}

object EventsourcedBookingWithoutExpiration {

  def behavior[F[_]: Monad]: EventsourcedBehavior[
    EitherK[Booking, BookingCommandRejection, ?[_]],
    F,
    Option[BookingState],
    BookingEvent
  ] =
    EventsourcedBehavior
      .optionalRejectable(
        new EventsourcedBookingWithoutExpiration(),
        BookingState.init,
        _.handleEvent(_)
      )
} 

package ru.pavkin.booking.booking.entity

import java.time.Instant

import cats.data.NonEmptyList
import ru.pavkin.booking.common.models._

sealed trait BookingEvent extends Product with Serializable

case class BookingPlaced(clientId: ClientId, concertId: ConcertId, seats: NonEmptyList[Seat])
    extends BookingEvent
case class BookingConfirmed(tickets: NonEmptyList[Ticket], expiresAt: Option[Instant])
    extends BookingEvent
case class BookingDenied(reason: String) extends BookingEvent
case class BookingCancelled(reason: String) extends BookingEvent
case object BookingExpired extends BookingEvent
case class BookingPaid(paymentId: PaymentId) extends BookingEvent
case object BookingSettled extends BookingEvent 

package ru.pavkin.booking.booking.entity

import java.time.Instant

import aecor.macros.boopickleWireProtocol
import cats.data.NonEmptyList
import cats.tagless.autoFunctorK
import ru.pavkin.booking.common.models._
import boopickle.Default._
import BookingWireCodecs._

@autoFunctorK(false)
@boopickleWireProtocol
trait Booking[F[_]] {

  def place(client: ClientId, concert: ConcertId, seats: NonEmptyList[Seat]): F[Unit]
  def confirm(tickets: NonEmptyList[Ticket], expiresAt: Option[Instant]): F[Unit]
  def deny(reason: String): F[Unit]
  def cancel(reason: String): F[Unit]
  def receivePayment(paymentId: PaymentId): F[Unit]
  def expire: F[Unit]
  def status: F[BookingStatus]
}

object Booking 

package ru.pavkin.booking.booking.service

import java.time.temporal.ChronoUnit
import java.time.{ Duration, Instant }
import java.util.concurrent.TimeUnit

import cats.Monad
import cats.data.NonEmptyList
import cats.effect.{ Clock, Sync }
import cats.effect.concurrent.Ref
import cats.implicits._
import ru.pavkin.booking.booking.service.TicketReservationService._
import ru.pavkin.booking.booking.service.StubConfirmationService.ConcertState
import ru.pavkin.booking.common.models._

class StubConfirmationService[F[_]: Monad](clock: Clock[F],
                                           state: Ref[F, Map[ConcertId, ConcertState]])
    extends TicketReservationService[F] {

  val expireAfter: Duration = Duration.of(6, ChronoUnit.HOURS)

  def reserve(bookingId: BookingKey,
           concertId: ConcertId,
           seats: NonEmptyList[Seat]): F[Either[ReservationFailure, Reservation]] =
    clock
      .realTime(TimeUnit.MILLISECONDS)
      .map(Instant.ofEpochMilli)
      .flatMap(
        now =>
          state.modify[Either[ReservationFailure, Reservation]](
            concerts =>
              concerts.get(concertId) match {
                case None => concerts -> Left(UnknownSeats)
                case Some(concertState) =>
                  concertState
                    .book(bookingId, seats)
                    .fold(e => concerts -> Left(e), {
                      case (c, t) =>
                        concerts.updated(concertId, c) -> Right(
                          Reservation(t, Some(now.plus(expireAfter)))
                        )
                    })

            }
        )
      )

  def release(bookingId: BookingKey): F[Either[ReleaseFailure, Unit]] =
    state.modify[Either[ReleaseFailure, Unit]](
      concerts =>
        Either
          .fromOption(concerts.find(_._2.bookedSeats.contains(bookingId)), UnknownBooking)
          .flatMap {
            case (concertId, concertState) =>
              concertState.release(bookingId).map(concertId -> _)
          } match {
          case Left(value)                  => concerts -> Left(value)
          case Right((concertId, newState)) => concerts.updated(concertId, newState) -> Right(())
      }
    )
}

object StubConfirmationService {

  def apply[F[_]: Sync](clock: Clock[F],
                        initial: Map[ConcertId, ConcertState]): F[StubConfirmationService[F]] =
    Ref.of(initial).map(new StubConfirmationService(clock, _))

  case class ConcertState(prices: Map[Seat, Money],
                          availableSeats: Set[Seat],
                          bookedSeats: Map[BookingKey, NonEmptyList[Seat]]) {

    def book(
      bookingId: BookingKey,
      seats: NonEmptyList[Seat]
    ): Either[ReservationFailure, (ConcertState, NonEmptyList[Ticket])] =
      if (bookedSeats.contains(bookingId)) Left(SeatsAlreadyBooked)
      else if (!seats.forall(availableSeats)) Left(SeatsAlreadyBooked)
      else if (!seats.forall(prices.contains)) Left(UnknownSeats)
      else
        Right(
          copy(
            availableSeats = availableSeats.diff(seats.toList.toSet),
            bookedSeats = bookedSeats.updated(bookingId, seats)
          ) -> seats.map(s => Ticket(s, prices(s)))
        )

    def release(bookingId: BookingKey): Either[ReleaseFailure, ConcertState] =
      bookedSeats.get(bookingId) match {
        case Some(booked) =>
          Right(
            copy(
              availableSeats = availableSeats ++ booked.toList.toSet,
              bookedSeats = bookedSeats - bookingId
            )
          )
        case None => Left(UnknownBooking)
      }
  }

} 

package ru.pavkin.booking.booking.service

import java.time.Instant

import cats.data.NonEmptyList
import ru.pavkin.booking.booking.service.TicketReservationService.{
  Reservation,
  ReservationFailure,
  ReleaseFailure
}
import ru.pavkin.booking.common.models.{ BookingKey, ConcertId, Seat, Ticket }

trait TicketReservationService[F[_]] {

  def reserve(bookingId: BookingKey,
              concertId: ConcertId,
              seats: NonEmptyList[Seat]): F[Either[ReservationFailure, Reservation]]

  def release(bookingId: BookingKey): F[Either[ReleaseFailure, Unit]]
}

object TicketReservationService {

  case class Reservation(tickets: NonEmptyList[Ticket], expiresAt: Option[Instant])

  sealed trait ReservationFailure
  case object SeatsAlreadyBooked extends ReservationFailure
  case object UnknownSeats extends ReservationFailure
  case object DuplicateSeats extends ReservationFailure

  sealed trait ReleaseFailure
  case object UnknownBooking extends ReleaseFailure
} 

package ru.pavkin.booking.booking.endpoint

import java.util.UUID

import cats.data.NonEmptyList
import cats.effect.Sync
import cats.implicits._
import ru.pavkin.booking.booking.booking.Bookings
import ru.pavkin.booking.booking.entity.{ BookingCommandRejection, BookingNotFound }
import ru.pavkin.booking.booking.view.{ BookingView, BookingViewRepository }
import ru.pavkin.booking.common.models.{ BookingKey, ClientId, ConcertId, Seat }

trait BookingEndpoint[F[_]] {
  def placeBooking(client: ClientId,
                   concertId: ConcertId,
                   seats: NonEmptyList[Seat]): F[Either[BookingCommandRejection, Unit]]

  def cancelBooking(clientId: ClientId,
                    bookingId: BookingKey,
                    reason: String): F[Either[BookingCommandRejection, Unit]]

  def clientBookings(client: ClientId): F[List[BookingView]]

}

final class DefaultBookingEndpoint[F[_]](
  bookings: Bookings[F],
  bookingsView: BookingViewRepository[F]
)(implicit F: Sync[F])
    extends BookingEndpoint[F] {

  def placeBooking(client: ClientId,
                   concertId: ConcertId,
                   seats: NonEmptyList[Seat]): F[Either[BookingCommandRejection, Unit]] =
    for {
      id <- Sync[F].delay(UUID.randomUUID())
      result <- bookings(BookingKey(id.toString)).place(client, concertId, seats)
    } yield result

  def cancelBooking(clientId: ClientId,
                    bookingId: BookingKey,
                    reason: String): F[Either[BookingCommandRejection, Unit]] =
    bookingsView.get(bookingId).flatMap {
      case None                               => F.pure(Left(BookingNotFound))
      case Some(b) if b.clientId =!= clientId => F.pure(Left(BookingNotFound))
      case Some(_)                            => bookings(bookingId).cancel(reason)
    }

  def clientBookings(client: ClientId): F[List[BookingView]] =
    bookingsView.byClient(client)
} 

package ru.pavkin.booking

import aecor.data.{ Committable, ConsumerId }
import cats.data.NonEmptyList
import cats.effect._
import fs2.kafka.{ AutoOffsetReset, ConsumerSettings, _ }
import org.apache.kafka.common.serialization.StringDeserializer
import ru.pavkin.payment.event.PaymentReceived
import ru.pavkin.payment.kafka.PaymentReceivedEventDeserializer

import scala.concurrent.ExecutionContext

final class KafkaWirings[F[_]](
  val paymentReceivedEventStream: ConsumerId => fs2.Stream[F, Committable[F, PaymentReceived]]
)

object KafkaWirings {

  def apply[F[_]: ConcurrentEffect: ContextShift: Timer]: KafkaWirings[F] = {

    def paymentReceivedEventStream(
      consumerId: ConsumerId
    ): fs2.Stream[F, Committable[F, PaymentReceived]] =
      for {
        executionContext <- consumerExecutionContextStream[F]
        settings = bookingPaymentProcessSourceSettings(executionContext).withGroupId(
          consumerId.value
        )
        consumer <- consumerStream[F].using(settings)
        _ <- consumer.subscribe(paymentReceivedTopic)
        stream <- consumer.stream.map(
                   m => Committable(m.committableOffset.commit, m.record.value())
                 )
      } yield stream

    new KafkaWirings[F](paymentReceivedEventStream)
  }

  def bookingPaymentProcessSourceSettings(
    ec: ExecutionContext
  ): ConsumerSettings[String, PaymentReceived] =
    ConsumerSettings(
      keyDeserializer = new StringDeserializer,
      valueDeserializer = new PaymentReceivedEventDeserializer,
      executionContext = ec
    ).withAutoOffsetReset(AutoOffsetReset.Earliest).withBootstrapServers("0.0.0.0:9092")

  val paymentReceivedTopic: NonEmptyList[String] = NonEmptyList.one("PaymentReceived")
} 

package com.comcast.ip4s

import java.net.{InetAddress, UnknownHostException}

import cats.data.NonEmptyList
import cats.effect.Sync

private[ip4s] trait HostnamePlatform { self: Hostname =>

  
  def resolveAll[F[_]: Sync]: F[Option[NonEmptyList[IpAddress]]] =
    Sync[F].delay {
      try {
        val addrs = InetAddress.getAllByName(self.toString)
        NonEmptyList.fromList(addrs.toList.flatMap(addr => IpAddress.fromBytes(addr.getAddress)))
      } catch {
        case _: UnknownHostException => None
      }
    }
} 

package com.softwaremill.diffx.cats

import cats.data.{NonEmptyChain, NonEmptyList, NonEmptySet, NonEmptyVector}
import com.softwaremill.diffx.{Derived, Diff}
import com.softwaremill.diffx.Diff._

trait DiffCatsInstances {
  implicit def diffNel[T: Diff]: Derived[Diff[NonEmptyList[T]]] =
    Derived(Diff[List[T]].contramap[NonEmptyList[T]](_.toList))

  implicit def diffNec[T: Diff]: Derived[Diff[NonEmptyChain[T]]] =
    Derived(Diff[List[T]].contramap[NonEmptyChain[T]](_.toChain.toList))

  implicit def diffNes[T: Diff]: Derived[Diff[NonEmptySet[T]]] =
    Derived(Diff[Set[T]].contramap[NonEmptySet[T]](_.toSortedSet))

  implicit def diffNev[T: Diff]: Derived[Diff[NonEmptyVector[T]]] =
    Derived(Diff[List[T]].contramap[NonEmptyVector[T]](_.toVector.toList))
} 

package com.twilio.guardrail
package terms

import cats.Monad
import cats.data.NonEmptyList
import com.twilio.guardrail.core.{ Mappish, Tracker }
import com.twilio.guardrail.languages.LA
import io.swagger.v3.oas.models._
import io.swagger.v3.oas.models.media.{ ArraySchema, Schema }
import io.swagger.v3.oas.models.parameters.{ Parameter, RequestBody }
import io.swagger.v3.oas.models.responses.ApiResponse
import io.swagger.v3.oas.models.security.{ SecurityScheme => SwSecurityScheme }

abstract class SwaggerLogAdapter[F[_]] {
  def schemaToString(value: Schema[_]): String = "    " + value.toString().linesIterator.filterNot(_.contains(": null")).mkString("\n    ")
  def function[A](name: String): F[A] => F[A]
  def push(name: String): F[Unit]
  def pop: F[Unit]
  def debug(message: String): F[Unit]
  def info(message: String): F[Unit]
  def warning(message: String): F[Unit]
  def error(message: String): F[Unit]
}

abstract class SwaggerTerms[L <: LA, F[_]] {
  def MonadF: Monad[F]

  def extractCommonRequestBodies(components: Option[Components]): F[Map[String, RequestBody]]
  def extractOperations(
      paths: Tracker[Mappish[List, String, PathItem]],
      commonRequestBodies: Map[String, RequestBody],
      globalSecurityRequirements: Option[SecurityRequirements]
  ): F[List[RouteMeta]]
  def extractApiKeySecurityScheme(schemeName: String, securityScheme: SwSecurityScheme, tpe: Option[L#Type]): F[ApiKeySecurityScheme[L]]
  def extractHttpSecurityScheme(schemeName: String, securityScheme: SwSecurityScheme, tpe: Option[L#Type]): F[HttpSecurityScheme[L]]
  def extractOpenIdConnectSecurityScheme(schemeName: String, securityScheme: SwSecurityScheme, tpe: Option[L#Type]): F[OpenIdConnectSecurityScheme[L]]
  def extractOAuth2SecurityScheme(schemeName: String, securityScheme: SwSecurityScheme, tpe: Option[L#Type]): F[OAuth2SecurityScheme[L]]
  def getClassName(operation: Tracker[Operation], vendorPrefixes: List[String]): F[List[String]]
  def getParameterName(parameter: Parameter): F[String]
  def getBodyParameterSchema(parameter: Tracker[Parameter]): F[Tracker[Schema[_]]]
  def getHeaderParameterType(parameter: Tracker[Parameter]): F[Tracker[String]]
  def getPathParameterType(parameter: Tracker[Parameter]): F[Tracker[String]]
  def getQueryParameterType(parameter: Tracker[Parameter]): F[Tracker[String]]
  def getCookieParameterType(parameter: Tracker[Parameter]): F[Tracker[String]]
  def getFormParameterType(parameter: Tracker[Parameter]): F[Tracker[String]]
  def getRefParameterRef(parameter: Tracker[Parameter]): F[Tracker[String]]
  def getSerializableParameterType(parameter: Tracker[Parameter]): F[Tracker[String]]
  def fallbackParameterHandler(parameter: Tracker[Parameter]): F[SwaggerUtil.ResolvedType[L]]
  def getOperationId(operation: Tracker[Operation]): F[String]
  def getResponses(operationId: String, operation: Tracker[Operation]): F[NonEmptyList[(String, Tracker[ApiResponse])]]
  def getSimpleRef(ref: Tracker[Option[Schema[_]]]): F[String]
  def getItems(arr: Tracker[ArraySchema]): F[Tracker[Schema[_]]]
  def getType(model: Tracker[Schema[_]]): F[Tracker[String]]
  def fallbackPropertyTypeHandler(prop: Tracker[Schema[_]]): F[L#Type]
  def resolveType(name: String, protocolElems: List[StrictProtocolElems[L]]): F[StrictProtocolElems[L]]
  def fallbackResolveElems(lazyElems: List[LazyProtocolElems[L]]): F[List[StrictProtocolElems[L]]]
  def log: SwaggerLogAdapter[F]
} 

package com.twilio.guardrail
package terms

import cats.Monad
import cats.data.NonEmptyList
import com.twilio.guardrail.languages.LA
import com.twilio.guardrail.generators.Framework

abstract class CoreTerms[L <: LA, F[_]] {
  def MonadF: Monad[F]
  def getDefaultFramework: F[Option[String]]
  def extractGenerator(context: Context, defaultFramework: Option[String]): F[Framework[L, Target]]
  def parseArgs(args: Array[String]): F[List[Args]]
  def validateArgs(parsed: List[Args]): F[NonEmptyList[Args]]
  def processArgSet(targetInterpreter: Framework[L, Target])(args: Args): F[ReadSwagger[Target[List[WriteTree]]]]
  def copy(
      newMonadF: Monad[F] = MonadF,
      newGetDefaultFramework: F[Option[String]] = getDefaultFramework,
      newExtractGenerator: (Context, Option[String]) => F[Framework[L, Target]] = extractGenerator _,
      newParseArgs: Array[String] => F[List[Args]] = parseArgs _,
      newValidateArgs: List[Args] => F[NonEmptyList[Args]] = validateArgs _,
      newProcessArgSet: Framework[L, Target] => Args => F[ReadSwagger[Target[List[WriteTree]]]] = processArgSet _
  ) = new CoreTerms[L, F] {
    def MonadF                                                               = newMonadF
    def getDefaultFramework                                                  = newGetDefaultFramework
    def extractGenerator(context: Context, defaultFramework: Option[String]) = newExtractGenerator(context, defaultFramework)
    def parseArgs(args: Array[String])                                       = newParseArgs(args)
    def validateArgs(parsed: List[Args])                                     = newValidateArgs(parsed)
    def processArgSet(targetInterpreter: Framework[L, Target])(args: Args)   = newProcessArgSet(targetInterpreter)(args)
  }
}
object CoreTerms {
  implicit def coreTerm[L <: LA, F[_]](implicit ev: CoreTerms[L, F]): CoreTerms[L, F] = ev
} 

package com.twilio.guardrail

import cats.data.NonEmptyList
import cats.implicits._
import com.twilio.guardrail.languages.LA
import com.twilio.guardrail.protocol.terms.client.ClientTerms
import com.twilio.guardrail.protocol.terms.Responses
import com.twilio.guardrail.terms.framework.FrameworkTerms
import com.twilio.guardrail.terms.{ LanguageTerms, RouteMeta, SecurityScheme, SwaggerTerms }
import java.net.URI

case class Clients[L <: LA](clients: List[Client[L]], supportDefinitions: List[SupportDefinition[L]])
case class Client[L <: LA](
    pkg: List[String],
    clientName: String,
    imports: List[L#Import],
    staticDefns: StaticDefns[L],
    client: NonEmptyList[Either[L#Trait, L#ClassDefinition]],
    responseDefinitions: List[L#Definition]
)
case class RenderedClientOperation[L <: LA](
    clientOperation: L#Definition,
    supportDefinitions: List[L#Definition]
)

object ClientGenerator {
  def fromSwagger[L <: LA, F[_]](context: Context, frameworkImports: List[L#Import])(
      serverUrls: Option[NonEmptyList[URI]],
      basePath: Option[String],
      groupedRoutes: List[(List[String], List[RouteMeta])]
  )(
      protocolElems: List[StrictProtocolElems[L]],
      securitySchemes: Map[String, SecurityScheme[L]]
  )(implicit C: ClientTerms[L, F], Fw: FrameworkTerms[L, F], Sc: LanguageTerms[L, F], Sw: SwaggerTerms[L, F]): F[Clients[L]] = {
    import C._
    import Sw._
    import Sc._
    for {
      clientImports      <- getImports(context.tracing)
      clientExtraImports <- getExtraImports(context.tracing)
      supportDefinitions <- generateSupportDefinitions(context.tracing, securitySchemes)
      clients <- groupedRoutes.traverse({
        case (className, unsortedRoutes) =>
          val routes = unsortedRoutes.sortBy(r => (r.path.unwrapTracker, r.method))
          for {
            clientName <- formatTypeName(className.lastOption.getOrElse(""), Some("Client"))
            responseClientPair <- routes.traverse {
              case route @ RouteMeta(path, method, operation, securityRequirements) =>
                for {
                  operationId         <- getOperationId(operation)
                  responses           <- Responses.getResponses[L, F](operationId, operation, protocolElems)
                  responseClsName     <- formatTypeName(operationId, Some("Response"))
                  responseDefinitions <- generateResponseDefinitions(responseClsName, responses, protocolElems)
                  parameters          <- route.getParameters[L, F](protocolElems)
                  methodName          <- formatMethodName(operationId)
                  clientOp            <- generateClientOperation(className, responseClsName, context.tracing, securitySchemes, parameters)(route, methodName, responses)
                } yield (responseDefinitions, clientOp)
            }
            (responseDefinitions, clientOperations) = responseClientPair.unzip
            tracingName                             = Option(className.mkString("-")).filterNot(_.isEmpty)
            ctorArgs    <- clientClsArgs(tracingName, serverUrls, context.tracing)
            staticDefns <- buildStaticDefns(clientName, tracingName, serverUrls, ctorArgs, context.tracing)
            client <- buildClient(
              clientName,
              tracingName,
              serverUrls,
              basePath,
              ctorArgs,
              clientOperations.map(_.clientOperation),
              clientOperations.flatMap(_.supportDefinitions),
              context.tracing
            )
          } yield {
            Client[L](className, clientName, (clientImports ++ frameworkImports ++ clientExtraImports), staticDefns, client, responseDefinitions.flatten)
          }
      })
    } yield Clients[L](clients, supportDefinitions)
  }
} 

package com.twilio.guardrail.generators.syntax

import cats.data.NonEmptyList
import com.twilio.guardrail.{ StaticDefns, SwaggerUtil, Target }
import com.twilio.guardrail.core.Tracker
import com.twilio.guardrail.generators.{ LanguageParameter, RawParameterName, RawParameterType }
import com.twilio.guardrail.languages.ScalaLanguage
import com.twilio.guardrail.generators.operations.TracingLabelFormatter
import scala.meta._

object Scala {
  implicit class RichRawParameterName(parameter: RawParameterName) {
    import _root_.scala.meta._
    def toLit: Lit.String = Lit.String(parameter.value)
  }

  implicit class ScalaTracingLabel(value: TracingLabelFormatter) {
    def toLit: Lit.String = Lit.String(s"${value.context}:${value.operationId}")
  }

  implicit class RichLanguageParameter(value: LanguageParameter.type) {
    import _root_.scala.meta._
    import com.twilio.guardrail.languages.ScalaLanguage
    def fromParam(param: Term.Param, rawType: Option[String] = Some("string"), rawFormat: Option[String] = None): LanguageParameter[ScalaLanguage] =
      param match {
        case param @ Term.Param(_, name, decltype, _) =>
          val tpe: Type = decltype
            .flatMap({
              case tpe @ t"Option[$_]" => Some(tpe)
              case Type.ByName(tpe)    => Some(tpe)
              case tpe @ Type.Name(_)  => Some(tpe)
              case _                   => None
            })
            .getOrElse(t"Nothing")
          new LanguageParameter[ScalaLanguage](
            None,
            param,
            Term.Name(name.value),
            RawParameterName(name.value),
            tpe,
            RawParameterType(rawType, rawFormat),
            true,
            None,
            false
          )
      }
  }

  implicit class ExtendedUnzip[T1, T2, T3, T4, T5, T6, T7, T8](xs: NonEmptyList[(T1, T2, T3, T4, T5, T6, T7, T8)]) {
    def unzip8: (List[T1], List[T2], List[T3], List[T4], List[T5], List[T6], List[T7], List[T8]) =
      xs.foldLeft(
        (List.empty[T1], List.empty[T2], List.empty[T3], List.empty[T4], List.empty[T5], List.empty[T6], List.empty[T7], List.empty[T8])
      ) {
        case ((v1a, v2a, v3a, v4a, v5a, v6a, v7a, v8a), (v1, v2, v3, v4, v5, v6, v7, v8)) =>
          (v1a :+ v1, v2a :+ v2, v3a :+ v3, v4a :+ v4, v5a :+ v5, v6a :+ v6, v7a :+ v7, v8a :+ v8)
      }
  }

  val GENERATED_CODE_COMMENT: String =
    s"""
       |""".stripMargin

  def companionForStaticDefns(staticDefns: StaticDefns[ScalaLanguage]): Defn.Object =
    q"""
    object ${Term.Name(staticDefns.className)} {
      ..${staticDefns.extraImports}
      ..${staticDefns.definitions}
    }
    """

  def generateUrlPathParams(path: Tracker[String], pathArgs: List[LanguageParameter[ScalaLanguage]]): Target[Term] =
    SwaggerUtil.paths.generateUrlPathParams[ScalaLanguage](
      path,
      pathArgs,
      Lit.String(_),
      name => q"Formatter.addPath(${name})",
      q"host + basePath",
      (a, b) => q"${a} + ${b}"
    )
} 

package com.twilio.guardrail.generators

import cats.data.NonEmptyList
import java.util.Locale
import java.util.regex.Matcher.quoteReplacement
import io.swagger.v3.oas.models.{ Operation, PathItem }
import io.swagger.v3.oas.models.media.Schema
import io.swagger.v3.oas.models.parameters.Parameter
import scala.collection.IterableLike
import scala.collection.generic.CanBuildFrom
import scala.language.implicitConversions

package syntax {
  class RichNotNullShower[A](value: A) {
    def showNotNull: String = showNotNullIndented(0)
    def showNotNullIndented(indent: Int): String =
      ("  " * indent) + value.toString().linesIterator.filterNot(_.contains(": null")).mkString("\n" + ("  " * indent))
  }

  class RichCollection[A, Repr](xs: IterableLike[A, Repr]) {
    def distinctBy[B, That](f: A => B)(implicit cbf: CanBuildFrom[Repr, A, That]): That = {
      val builder = cbf(xs.repr)
      val i       = xs.iterator
      var set     = Set[B]()
      while (i.hasNext) {
        val o = i.next
        val b = f(o)
        if (!set(b)) {
          set += b
          builder += o
        }
      }
      builder.result
    }
  }
}

package object syntax {
  val GENERATED_CODE_COMMENT_LINES: List[String] = List(
    "This file was generated by Guardrail (https://github.com/twilio/guardrail).",
    "Modifications will be overwritten; instead edit the OpenAPI/Swagger spec file."
  )

  
  private val SPLIT_DELIMITERS = "[-_\\s\\.]+".r
  private val BOUNDARY_SPLITTERS = List(
    "([^A-Z])([A-Z])".r,
    "([A-Z]+)([A-Z][a-z]+)".r
  )

  implicit class RichString(private val s: String) extends AnyVal {
    private def splitParts(s: String): List[String] =
      BOUNDARY_SPLITTERS
        .foldLeft(SPLIT_DELIMITERS.split(s))(
          (last, splitter) => last.flatMap(part => splitter.replaceAllIn(part, m => quoteReplacement(m.group(1) + "-" + m.group(2))).split("-"))
        )
        .map(_.toLowerCase(Locale.US))
        .toList

    def toPascalCase: String = splitParts(s).map(_.capitalize).mkString

    def toCamelCase: String =
      NonEmptyList
        .fromList(splitParts(s))
        .fold("")(
          parts => parts.head + parts.tail.map(_.capitalize).mkString
        )

    def toSnakeCase: String = splitParts(s).mkString("_")

    def toDashedCase: String = splitParts(s).mkString("-")

    def uncapitalized: String =
      if (s.nonEmpty) {
        val inUnPacked              = s.toCharArray
        val lowercaseFirstCharacter = Character.toLowerCase(inUnPacked(0))
        new String(lowercaseFirstCharacter +: inUnPacked.tail)
      } else s

  }

  implicit def RichSchema: Schema[_] => RichNotNullShower[Schema[_]]    = new RichNotNullShower[Schema[_]](_)
  implicit def RichOperation: Operation => RichNotNullShower[Operation] = new RichNotNullShower[Operation](_)
  implicit def RichPathItem: PathItem => RichNotNullShower[PathItem]    = new RichNotNullShower[PathItem](_)
  implicit def RichParameter: Parameter => RichNotNullShower[Parameter] = new RichNotNullShower[Parameter](_)

  implicit def toRichCollection[A, Repr](xs: IterableLike[A, Repr]): RichCollection[A, Repr] = new RichCollection(xs)
} 

package com.twilio.guardrail.generators.Scala

import cats.data.NonEmptyList
import cats.implicits._
import com.twilio.guardrail.Target
import com.twilio.guardrail.core.Tracker
import com.twilio.guardrail.protocol.terms.{ ApplicationJson, ContentType, TextPlain }
import scala.meta._

object AkkaHttpHelper {
  def generateDecoder(tpe: Type, consumes: Tracker[NonEmptyList[ContentType]]): Target[(Term, Type)] = {
    val baseType = tpe match {
      case t"Option[$x]" => x
      case x             => x
    }

    for {
      unmarshallers <- consumes.indexedDistribute.toList.flatTraverse {
        case Tracker(_, ApplicationJson)   => Target.pure(List(q"structuredJsonEntityUnmarshaller"))
        case Tracker(_, TextPlain)         => Target.pure(List(q"stringyJsonEntityUnmarshaller"))
        case Tracker(history, contentType) => Target.log.warning(s"Unable to generate decoder for ${contentType} (${history})").map(_ => List.empty[Term.Name])
      }
      unmarshaller <- unmarshallers match {
        case Nil      => Target.raiseUserError(s"No decoders available (${consumes.showHistory})")
        case x :: Nil => Target.pure(x)
        case xs       => Target.pure(q"Unmarshaller.firstOf(..${xs})")
      }
    } yield {
      val decoder = q""" {
        ${unmarshaller}.flatMap(_ => _ => json => io.circe.Decoder[${baseType}].decodeJson(json).fold(FastFuture.failed, FastFuture.successful))
      }
      """
      (decoder, baseType)
    }
  }
} 

package com.twilio.guardrail.generators.Java

import com.twilio.guardrail.Target
import com.twilio.guardrail.languages.JavaLanguage
import com.twilio.guardrail.protocol.terms.client._
import cats.data.NonEmptyList
import com.twilio.guardrail.generators.LanguageParameters
import com.twilio.guardrail.protocol.terms.Responses
import com.twilio.guardrail.terms.{ RouteMeta, SecurityScheme }
import com.twilio.guardrail.StrictProtocolElems
import java.net.URI

object SpringMvcClientGenerator {

  object ClientTermInterp extends ClientTerms[JavaLanguage, Target] {
    def MonadF = Target.targetInstances
    def generateClientOperation(
        className: List[String],
        responseClsName: String,
        tracing: Boolean,
        securitySchemes: Map[String, SecurityScheme[JavaLanguage]],
        parameters: LanguageParameters[JavaLanguage]
    )(
        route: RouteMeta,
        methodName: String,
        responses: Responses[JavaLanguage]
    ) =
      Target.raiseUserError("spring client generation is not currently supported")
    def getImports(tracing: Boolean) =
      Target.raiseUserError("spring client generation is not currently supported")
    def getExtraImports(tracing: Boolean) =
      Target.raiseUserError("spring client generation is not currently supported")
    def clientClsArgs(
        tracingName: Option[String],
        serverUrls: Option[NonEmptyList[URI]],
        tracing: Boolean
    ) =
      Target.raiseUserError("spring client generation is not currently supported")
    def generateResponseDefinitions(
        responseClsName: String,
        responses: Responses[JavaLanguage],
        protocolElems: List[StrictProtocolElems[JavaLanguage]]
    ) =
      Target.raiseUserError("spring client generation is not currently supported")
    def generateSupportDefinitions(
        tracing: Boolean,
        securitySchemes: Map[String, SecurityScheme[JavaLanguage]]
    ) =
      Target.raiseUserError("spring client generation is not currently supported")
    def buildStaticDefns(
        clientName: String,
        tracingName: Option[String],
        serverUrls: Option[NonEmptyList[URI]],
        ctorArgs: List[List[com.github.javaparser.ast.body.Parameter]],
        tracing: Boolean
    ) =
      Target.raiseUserError("spring client generation is not currently supported")
    def buildClient(
        clientName: String,
        tracingName: Option[String],
        serverUrls: Option[NonEmptyList[URI]],
        basePath: Option[String],
        ctorArgs: List[List[com.github.javaparser.ast.body.Parameter]],
        clientCalls: List[com.github.javaparser.ast.body.BodyDeclaration[_ <: com.github.javaparser.ast.body.BodyDeclaration[_]]],
        supportDefinitions: List[com.github.javaparser.ast.body.BodyDeclaration[_ <: com.github.javaparser.ast.body.BodyDeclaration[_]]],
        tracing: Boolean
    ) =
      Target.raiseUserError("spring client generation is not currently supported")
  }
} 

package com.twilio.guardrail.generators.Java

import cats.data.NonEmptyList
import cats.syntax.foldable._
import com.github.javaparser.ast.`type`.Type
import com.twilio.guardrail.core.Tracker
import com.twilio.guardrail.generators.LanguageParameters
import com.twilio.guardrail.generators.syntax.Java._
import com.twilio.guardrail.languages.JavaLanguage
import com.twilio.guardrail.protocol.terms._
import io.swagger.v3.oas.models.Operation

object DropwizardHelpers {
  private val CONSUMES_PRIORITY = NonEmptyList.of(ApplicationJson, TextPlain, OctetStream)
  private val PRODUCES_PRIORITY = NonEmptyList.of(ApplicationJson, TextPlain, OctetStream)

  def getBestConsumes(operation: Tracker[Operation], contentTypes: List[ContentType], parameters: LanguageParameters[JavaLanguage]): Option[ContentType] =
    if (parameters.formParams.nonEmpty) {
      if (parameters.formParams.exists(_.isFile) || contentTypes.contains(MultipartFormData)) {
        Some(MultipartFormData)
      } else {
        Some(UrlencodedFormData)
      }
    } else {
      parameters.bodyParams.map({ bodyParam =>
        CONSUMES_PRIORITY
          .collectFirstSome(ct => contentTypes.find(_ == ct))
          .orElse(contentTypes.collectFirst({ case tc: TextContent => tc }))
          .orElse(contentTypes.collectFirst({ case bc: BinaryContent => bc }))
          .getOrElse({
            val fallback =
              if (bodyParam.argType.isPrimitiveType || bodyParam.argType.isNamed("String")) TextPlain
              else ApplicationJson
            println(s"WARNING: no supported body param type at ${operation.showHistory}; falling back to $fallback")
            fallback
          })
      })
    }

  def getBestProduces(operationId: String, contentTypes: List[ContentType], response: Response[JavaLanguage]): Option[ContentType] =
    response.value
      .map(_._1)
      .flatMap({ valueType: Type =>
        PRODUCES_PRIORITY
          .collectFirstSome(ct => contentTypes.find(_ == ct))
          .orElse(contentTypes.collectFirst({ case tc: TextContent => tc }))
          .orElse(contentTypes.collectFirst({ case bc: BinaryContent => bc }))
          .orElse({
            val fallback = if (valueType.isNamed("String")) TextPlain else ApplicationJson
            println(
              s"WARNING: no supported body param type for operation '$operationId', response code ${response.statusCode}; falling back to ${fallback.value}"
            )
            Option(fallback)
          })
      })
} 

package com.twilio.guardrail
package generators

import com.twilio.guardrail.languages.JavaLanguage
import com.twilio.guardrail.generators.Java.JacksonGenerator
import com.twilio.guardrail.generators.Java.AsyncHttpClientClientGenerator
import com.twilio.guardrail.generators.Java.DropwizardGenerator
import com.twilio.guardrail.generators.Java.SpringMvcGenerator
import com.twilio.guardrail.generators.Java.DropwizardServerGenerator
import com.twilio.guardrail.generators.Java.SpringMvcServerGenerator
import cats.data.NonEmptyList

import com.twilio.guardrail.protocol.terms.protocol.{ ArrayProtocolTerms, EnumProtocolTerms, ModelProtocolTerms, PolyProtocolTerms, ProtocolSupportTerms }
import com.twilio.guardrail.protocol.terms.client.ClientTerms
import com.twilio.guardrail.protocol.terms.server.ServerTerms
import com.twilio.guardrail.terms.{ LanguageTerms, SwaggerTerms }
import com.twilio.guardrail.terms.framework.FrameworkTerms

object JavaModule extends AbstractModule[JavaLanguage] {
  def jackson: (
      ProtocolSupportTerms[JavaLanguage, Target],
      ModelProtocolTerms[JavaLanguage, Target],
      EnumProtocolTerms[JavaLanguage, Target],
      ArrayProtocolTerms[JavaLanguage, Target],
      PolyProtocolTerms[JavaLanguage, Target]
  ) = (
    JacksonGenerator.ProtocolSupportTermInterp,
    JacksonGenerator.ModelProtocolTermInterp,
    JacksonGenerator.EnumProtocolTermInterp,
    JacksonGenerator.ArrayProtocolTermInterp,
    JacksonGenerator.PolyProtocolTermInterp
  )

  def dropwizard: (
      ServerTerms[JavaLanguage, Target],
      FrameworkTerms[JavaLanguage, Target]
  ) = (DropwizardServerGenerator.ServerTermInterp, DropwizardGenerator.FrameworkInterp)
  def spring: (
      ServerTerms[JavaLanguage, Target],
      FrameworkTerms[JavaLanguage, Target]
  )                                                      = (SpringMvcServerGenerator.ServerTermInterp, SpringMvcGenerator.FrameworkInterp)
  def asyncHttpClient: ClientTerms[JavaLanguage, Target] = AsyncHttpClientClientGenerator.ClientTermInterp

  def extract(modules: NonEmptyList[String]): Target[Framework[JavaLanguage, Target]] =
    (for {
      (protocol, model, enum, array, poly) <- popModule("json", ("jackson", jackson))
      client                               <- popModule("client", ("async-http-client", asyncHttpClient))
      (server, framework)                  <- popModule("server", ("dropwizard", dropwizard), ("spring-mvc", spring))
    } yield new Framework[JavaLanguage, Target] {
      def ArrayProtocolInterp: ArrayProtocolTerms[JavaLanguage, Target]     = array
      def ClientInterp: ClientTerms[JavaLanguage, Target]                   = client
      def EnumProtocolInterp: EnumProtocolTerms[JavaLanguage, Target]       = enum
      def FrameworkInterp: FrameworkTerms[JavaLanguage, Target]             = framework
      def ModelProtocolInterp: ModelProtocolTerms[JavaLanguage, Target]     = model
      def PolyProtocolInterp: PolyProtocolTerms[JavaLanguage, Target]       = poly
      def ProtocolSupportInterp: ProtocolSupportTerms[JavaLanguage, Target] = protocol
      def ServerInterp: ServerTerms[JavaLanguage, Target]                   = server
      def SwaggerInterp: SwaggerTerms[JavaLanguage, Target]                 = SwaggerGenerator[JavaLanguage]
      def LanguageInterp: LanguageTerms[JavaLanguage, Target]               = JavaGenerator.JavaInterp
    }).runA(modules.toList.toSet)
} 

package com.agilelab.dataquality.common.instances

import cats.data.Validated.{Invalid, Valid}
import cats.data.{NonEmptyList, ValidatedNel}
import cats.implicits._
import com.agilelab.dataquality.common.enumerations.DBTypes
import com.agilelab.dataquality.common.models.DatabaseCommon
import com.agilelab.dataquality.common.parsers.ConfigReader
import com.agilelab.dataquality.common.parsers.DQConfig.AllErrorsOr
import com.typesafe.config.Config

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

object ConfigReaderInstances {

  private def parseString(str: String)(implicit conf: Config): AllErrorsOr[String] = {
    Try(conf.getString(str)) match {
      case Success(v) => Valid(v)
      case Failure(_) => Invalid(NonEmptyList.one(s"Field $str is missing"))
    }
  }

  private def parseStringEnumerated(str: String, enum: Set[String])(implicit conf: Config): AllErrorsOr[String] = {
    Try(conf.getString(str)) match {
      case Success(v) if enum.contains(v) => Valid(v)
      case Success(v) => Invalid(NonEmptyList.one(s"Unsupported value of $str: $v"))
      case Failure(_) => Invalid(NonEmptyList.one(s"Field $str is missing"))
    }
  }

  implicit val databaseReader: ConfigReader[DatabaseCommon] =
    new ConfigReader[DatabaseCommon] {
      def read(conf: Config, enums: Set[String]*): AllErrorsOr[DatabaseCommon] = {
        val id: AllErrorsOr[String] = parseString("id")(conf)
        val subtype: AllErrorsOr[String] = parseStringEnumerated("subtype", DBTypes.names)(conf)

        Try(conf.getConfig("config")) match {
          case Success(innerConf) =>
            val host: AllErrorsOr[String] = parseString("host")(innerConf)

            val port: AllErrorsOr[Option[Int]] = Valid(Try(innerConf.getString("port").toInt).toOption)
            val service: AllErrorsOr[Option[String]] = Valid(Try(innerConf.getString("service")).toOption)
            val user: AllErrorsOr[Option[String]] = Valid(Try(innerConf.getString("user")).toOption)
            val password: AllErrorsOr[Option[String]] = Valid(Try(innerConf.getString("password")).toOption)
            val schema: AllErrorsOr[Option[String]] = Valid(Try(innerConf.getString("schema")).toOption)

            (id, subtype, host, port, service, user, password, schema).mapN(DatabaseCommon.apply _)
          case Failure(_) => Invalid(NonEmptyList.one("Inner config is missing"))
        }
      }
    }

//  implicit val sourceReader: ConfigReader[SourceCommon] =
//    new ConfigReader[SourceCommon] {
//      override def read(value: Config): AllErrorsOr[SourceCommon] = ???
//    }
} 

package vinyldns.api.engine
import cats.data.NonEmptyList
import cats.effect.IO
import vinyldns.core.domain.record.RecordSetChange
import vinyldns.core.domain.zone.ZoneCommand
import vinyldns.core.health.HealthCheck.HealthCheck
import vinyldns.core.queue.{CommandMessage, MessageCount, MessageQueue, SendBatchResult}
import vinyldns.core.health.HealthCheck._

import scala.concurrent.duration.FiniteDuration

object TestMessageQueue extends MessageQueue {
  override def receive(count: MessageCount): IO[List[CommandMessage]] = IO(List())

  override def requeue(message: CommandMessage): IO[Unit] = IO.unit

  override def remove(message: CommandMessage): IO[Unit] = IO.unit

  override def changeMessageTimeout(message: CommandMessage, duration: FiniteDuration): IO[Unit] =
    IO.unit

  override def sendBatch[A <: ZoneCommand](messages: NonEmptyList[A]): IO[SendBatchResult[A]] = {
    val partition = messages.toList.partition {
      case bad: RecordSetChange if bad.recordSet.name == "bad" => false
      case _ => true
    }
    IO {
      SendBatchResult(partition._1, partition._2.map((new RuntimeException("BOO"), _)))
    }
  }

  override def send[A <: ZoneCommand](command: A): IO[Unit] = IO.unit

  override def healthCheck(): HealthCheck = IO.unit.attempt.asHealthCheck(TestMessageQueue.getClass)
} 

package cats.scalatest

import cats.data.Validated.{Invalid, Valid}
import cats.data.{NonEmptyList, ValidatedNel}

class ValidatedMatchersSpec extends TestBase with ValidatedMatchers {
  "ValidatedMatchers" should {
    val simpleFailureNel: ValidatedNel[String, Nothing] = Invalid(NonEmptyList.of(thisRecord, thisTobacconist))

    "Match one specific element in an Invalid NEL" in {
      simpleFailureNel should haveInvalid(thisRecord)
    }

    "Match multiple specific elements in an Invalid NEL" in {
      simpleFailureNel should (haveInvalid(thisRecord).and(haveInvalid(thisTobacconist)))
    }

    "Match a specific element of a single Invalid" in {
      Invalid(thisRecord) should beInvalid(thisRecord)
    }

    "Test whether a Validated instance is a Invalid w/o specific element value" in {
      Invalid(thisTobacconist) should be(invalid)
    }

    "By negating 'invalid', test whether a Validated instance is a Valid" in {
      Valid(hovercraft) should not be (invalid)
    }

    "Test whether a Validated instance is a Valid" in {
      Valid(hovercraft) should be(valid)
    }

    "By negating 'valid', test whether a Validated instance is an invalid" in {
      Invalid(thisTobacconist) should not be (valid)
    }

    "Match a specific element of a single Valid" in {
      Valid(hovercraft) should beValid(hovercraft)
    }

    "Match one specific type in an Invalid NEL" in {
      simpleFailureNel should haveAnInvalid[String]

      val nel: ValidatedNel[String, Nothing] = Invalid(NonEmptyList.of("test"))
      nel should haveAnInvalid[String]
      nel should haveAnInvalid[Any]
      nel shouldNot haveAnInvalid[Int]

      val nel2: ValidatedNel[Nothing, Unit] = Valid(())
      nel2 shouldNot haveAnInvalid[String]
      nel2 shouldNot haveAnInvalid[Unit]
    }
  }
} 

package cats.scalatest

import org.scalatest.exceptions.TestFailedException
import org.scalatest.enablers.Collecting
import org.scalatest.LoneElement._
import org.scalatest.Inspectors._
import cats.data.NonEmptyList

class NonEmptyListScalaTestInstancesSpec extends TestBase {
  import NonEmptyListScalaTestInstances._

  "loneElement" should {
    "apply an assertion when there is a single element" in {
      val nel: NonEmptyList[Int] = NonEmptyList.one(10)
      nel.loneElement should be <= 10
    }

    "should throw TestFailedException if the NonEmptyList has more elements" in {
      val nel: NonEmptyList[Int] = NonEmptyList.of(10, 16)
      val caught =
        intercept[TestFailedException] {
          nel.loneElement should ===(thisRecord)
        }
      if (isJVM)
        caught.failedCodeLineNumber.value should equal(thisLineNumber - 3)
      caught.failedCodeFileName.value should be("NonEmptyListScalaTestInstancesSpec.scala")
    }
  }

  "inspectors" should {
    "state something about all elements" in {
      val nel: NonEmptyList[Int] = NonEmptyList.of(1, 2, 3, 4, 5)
      forAll(nel)(_ should be > 0)
    }
  }

  "sizeOf" should {
    "return the size of the collection" in {
      val nel: NonEmptyList[Int] = NonEmptyList.of(1, 2)
      implicitly[Collecting[Int, NonEmptyList[Int]]].sizeOf(nel) shouldBe 2
    }
  }
} 

package cats
package derived

import alleycats.Pure
import cats.data.NonEmptyList
import cats.instances.all._
import cats.laws.discipline.SerializableTests
import shapeless.test.illTyped

class PureSuite extends KittensSuite {
  import PureSuite._
  import TestDefns._

  def testPure(context: String)(
    implicit lOption: Pure[LOption],
    pList: Pure[PList],
    caseClassWOption: Pure[CaseClassWOption],
    nelOption: Pure[NelOption],
    interleaved: Pure[Interleaved],
    boxColor: Pure[BoxColor]
  ): Unit = {
    test(s"$context.Pure[LOption]")(assert(lOption.pure(42) == Some(42) :: Nil))
    test(s"$context.Pure[PList]")(assert(pList.pure("Scala") == ("Scala" :: Nil, "Scala" :: Nil)))
    test(s"$context.Pure[CaseClassWOption]")(assert(caseClassWOption.pure(3.14) == CaseClassWOption(Some(3.14))))
    test(s"$context.Pure[NelOption]")(assert(nelOption.pure(42) == NonEmptyList.of(Some(42))))
    test(s"$context.Pure[Interleaved]")(assert(interleaved.pure('x') == Interleaved(0, 'x', 0, 'x' :: Nil, "")))
    test(s"$context.Pure respects existing instances")(assert(boxColor.pure(()) == Box(Color(255, 255, 255))))
    checkAll(s"$context.Pure is Serializable", SerializableTests.serializable(Pure[Interleaved]))
  }

  {
    import auto.pure._
    testPure("auto")
    illTyped("Pure[IList]")
    illTyped("Pure[Snoc]")
  }

  {
    import cached.pure._
    testPure("cached")
    illTyped("Pure[IList]")
    illTyped("Pure[Snoc]")
  }

  {
    import semiInstances._
    testPure("semiauto")
    illTyped("semiauto.pure[IList]")
    illTyped("semiauto.pure[Snoc]")
  }
}

object PureSuite {
  import TestDefns._

  type LOption[A] = List[Option[A]]
  type PList[A] = (List[A], List[A])
  type NelOption[A] = NonEmptyList[Option[A]]
  type BoxColor[A] = Box[Color[A]]

  object semiInstances {
    implicit val lOption: Pure[LOption] = semiauto.pure
    implicit val pList: Pure[PList] = semiauto.pure
    implicit val caseClassWOption: Pure[CaseClassWOption] = semiauto.pure
    implicit val nelOption: Pure[NelOption] = semiauto.pure
    implicit val interleaved: Pure[Interleaved] = semiauto.pure
    implicit val boxColor: Pure[BoxColor] = semiauto.pure
  }

  final case class Color[A](r: Int, g: Int, b: Int)
  object Color {

    implicit val pure: Pure[Color] = new Pure[Color] {
      def pure[A](value: A) = Color(255, 255, 255)
    }
  }
} 

package cats.derived

import alleycats.{EmptyK, Pure}
import alleycats.std.all._
import cats.data.NonEmptyList
import cats.laws.discipline.SerializableTests
import cats.instances.all._
import shapeless.test.illTyped

class EmptyKSuite extends KittensSuite {
  import EmptyKSuite._
  import TestDefns._

  def testEmptyK(context: String)(
    implicit lOption: EmptyK[LOption],
    pList: EmptyK[PList],
    caseClassWOption: EmptyK[CaseClassWOption],
    nelOption: EmptyK[NelOption],
    boxColor: EmptyK[BoxColor]
  ): Unit = {
    test(s"$context.EmptyK[LOption]")(assert(lOption.empty == Nil))
    test(s"$context.EmptyK[PList]")(assert(pList.empty == (Nil, Nil)))
    test(s"$context.EmptyK[CaseClassWOption]")(assert(caseClassWOption.empty == CaseClassWOption(None)))
    test(s"$context.EmptyK[NelOption]")(assert(nelOption.empty == NonEmptyList.of(None)))
    test(s"$context.EmptyK respects existing instances")(assert(boxColor.empty == Box(Color(255, 255, 255))))
    checkAll(s"$context.EmptyK is Serializable", SerializableTests.serializable(EmptyK[PList]))
  }

  implicit val pureBox: Pure[Box] = new Pure[Box] {
    def pure[A](a: A) = Box(a)
  }

  {
    import auto.emptyK._
    testEmptyK("auto")
    illTyped("EmptyK[IList]")
    illTyped("EmptyK[Snoc]")
  }

  {
    import cached.emptyK._
    testEmptyK("cached")
    illTyped("EmptyK[IList]")
    illTyped("EmptyK[Snoc]")
  }

  {
    import semiInstances._
    testEmptyK("semiauto")
    illTyped("semiauto.emptyK[IList]")
    illTyped("semiauto.emptyK[Snoc]")
  }
}

object EmptyKSuite {
  import TestDefns._

  type LOption[A] = List[Option[A]]
  type PList[A] = (List[A], List[A])
  type NelOption[A] = NonEmptyList[Option[A]]
  type BoxColor[A] = Box[Color[A]]

  object semiInstances {
    implicit val lOption: EmptyK[LOption] = semiauto.emptyK
    implicit val pList: EmptyK[PList] = semiauto.emptyK
    implicit val caseClassWOption: EmptyK[CaseClassWOption] = semiauto.emptyK
    implicit val nelOption: EmptyK[NelOption] = semiauto.emptyK
    implicit val boxColor: EmptyK[BoxColor] = semiauto.emptyK
  }

  final case class Color[A](r: Int, g: Int, b: Int)
  object Color {

    implicit val emptyK: EmptyK[Color] = new EmptyK[Color] {
      def empty[A] = Color(255, 255, 255)
    }
  }
} 

package cats.derived

import cats.NonEmptyTraverse
import cats.data.{NonEmptyList, NonEmptyVector, OneAnd}
import cats.instances.all._
import cats.laws.discipline.arbitrary._
import cats.laws.discipline.{NonEmptyTraverseTests, SerializableTests}

class NonEmptyTraverseSuite extends KittensSuite {
  import NonEmptyTraverseSuite._
  import TestDefns._
  import TestEqInstances._

  def testReducible(context: String)(
    implicit iCons: NonEmptyTraverse[ICons],
    tree: NonEmptyTraverse[Tree],
    nelSCons: NonEmptyTraverse[NelSCons],
    nelAndOne: NonEmptyTraverse[NelAndOne],
    listAndNel: NonEmptyTraverse[ListAndNel],
    interleaved: NonEmptyTraverse[Interleaved]
  ): Unit = {

    checkAll(
      s"$context.NonEmptyTraverse[ICons]",
      NonEmptyTraverseTests[ICons].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option]
    )

    checkAll(
      s"$context.NonEmptyTraverse[Tree]",
      NonEmptyTraverseTests[Tree].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option]
    )

    checkAll(
      s"$context.NonEmptyTraverse[NelSCons]",
      NonEmptyTraverseTests[NelSCons].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option]
    )

    checkAll(
      s"$context.NonEmptyTraverse[NelAndOne]",
      NonEmptyTraverseTests[NelAndOne].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option]
    )

    checkAll(
      s"$context.NonEmptyTraverse[ListAndNel]",
      NonEmptyTraverseTests[ListAndNel].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option]
    )

    checkAll(
      s"$context.NonEmptyTraverse[Interleaved]",
      NonEmptyTraverseTests[Interleaved].nonEmptyTraverse[Option, Int, Int, Int, Int, Option, Option]
    )

    checkAll(
      s"$context.NonEmptyTraverse is Serializable",
      SerializableTests.serializable(NonEmptyTraverse[Tree])
    )

    val n = 10000
    val largeIList = ICons(0, IList.fromSeq(1 until n))
    val largeSnoc: NelSCons[Int] = NonEmptyList.one(SCons(Snoc.fromSeq(1 until n), 0))

    test(s"$context.Traverse.nonEmptyTraverse is stack safe") {
      val actualIList = largeIList.nonEmptyTraverse(i => Option(i + 1)).map(IList.toList)
      val actualSnoc = largeSnoc.nonEmptyTraverse(i => Option(i + 1)).map(_.toList.flatMap(Snoc.toList))
      assert(actualIList.isDefined)
      assert(actualSnoc.isDefined)
    }
  }

  {
    import auto.nonEmptyTraverse._
    testReducible("auto")
  }

  {
    import cached.nonEmptyTraverse._
    testReducible("cached")
  }

  {
    import semiInstances._
    testReducible("semiauto")
  }
}

object NonEmptyTraverseSuite {
  import TestDefns._

  type NelSCons[A] = NonEmptyList[SCons[A]]
  type NelAndOne[A] = NonEmptyList[OneAnd[List, A]]
  type ListAndNel[A] = (List[A], NonEmptyList[A])

  object semiInstances {
    implicit val iCons: NonEmptyTraverse[ICons] = semiauto.nonEmptyTraverse
    implicit val tree: NonEmptyTraverse[Tree] = semiauto.nonEmptyTraverse
    implicit val nelSCons: NonEmptyTraverse[NelSCons] = semiauto.nonEmptyTraverse
    implicit val nelAndOne: NonEmptyTraverse[NelAndOne] = semiauto.nonEmptyTraverse
    implicit val listAndNel: NonEmptyTraverse[ListAndNel] = semiauto.nonEmptyTraverse
    implicit val interleaved: NonEmptyTraverse[Interleaved] = semiauto.nonEmptyTraverse
  }
} 

package io.hydrosphere.mist.master

import cats.data.NonEmptyList
import java.io.File

sealed trait FilterClause

object FilterClause {
  case class ByFunctionId(id: String) extends FilterClause
  case class ByWorkerId(id: String) extends FilterClause
  case class ByStatuses(statuses: NonEmptyList[JobDetails.Status]) extends FilterClause
}

case class JobDetailsRequest(
  limit: Int,
  offset: Int,
  filters: Seq[FilterClause]
) { self =>

  def withFilter(f: FilterClause): JobDetailsRequest = copy(filters = f +: filters)
  def withOptFilter(optF: Option[FilterClause]): JobDetailsRequest = 
    optF.fold(self)(f => self.withFilter(f))
}

object JobDetailsRequest {
  def apply(limit: Int, offset: Int): JobDetailsRequest = JobDetailsRequest(limit, offset, Seq.empty)
}

case class JobDetailsResponse(
  jobs: Seq[JobDetails],
  total: Int
) 

package io.hydrosphere.mist.master.store

import cats.data.NonEmptyList
import doobie.{Fragment, Fragments}
import doobie.implicits._
import io.hydrosphere.mist.master.FilterClause.{ByFunctionId, ByStatuses, ByWorkerId}
import io.hydrosphere.mist.master.{JobDetails, JobDetailsRecord, JobDetailsRequest}

class H2JobRequestSql extends JobRequestSql {
  override def update(jobDetails: JobDetails): Fragment = {
    val r: JobDetailsRecord = JobDetailsRecord(jobDetails)
    sql"""
      merge into job_details
      (
        path, class_name, namespace, parameters,
        external_id, function, action, source,
        job_id, start_time, end_time, job_result,
        status, worker_id, create_time
      ) key(job_id)
      values
      (
        ${r.path}, ${r.className}, ${r.namespace}, ${r.parameters},
        ${r.externalId}, ${r.function}, ${r.action}, ${r.source},
        ${r.jobId}, ${r.startTime}, ${r.endTime}, ${r.jobResult},
        ${r.status}, ${r.workerId}, ${r.createTime}
      )"""
  }
}

class PgJobRequestSql extends JobRequestSql {
  override def update(jobDetails: JobDetails): Fragment = {
    val r: JobDetailsRecord = JobDetailsRecord(jobDetails)
    sql"""
      insert into job_details
      (
        path, class_name, namespace, parameters,
        external_id, function, action, source,
        job_id, start_time, end_time, job_result,
        status, worker_id, create_time
      ) values
      (
        ${r.path}, ${r.className}, ${r.namespace}, ${r.parameters},
        ${r.externalId}, ${r.function}, ${r.action}, ${r.source},
        ${r.jobId}, ${r.startTime}, ${r.endTime}, ${r.jobResult},
        ${r.status}, ${r.workerId}, ${r.createTime}
      ) on conflict (job_id) do update set
        path = ${r.path},
        class_name = ${r.className},
        namespace = ${r.namespace},
        parameters = ${r.parameters},
        external_id = ${r.externalId},
        function = ${r.function},
        action = ${r.action},
        source = ${r.source},
        start_time = ${r.startTime},
        end_time = ${r.endTime},
        job_result = ${r.jobResult},
        status = ${r.status},
        worker_id = ${r.workerId},
        create_time = ${r.createTime}
    """
  }

}

object JobRequestSql {
  def apply(jdbcUrl: String): JobRequestSql = {
    jdbcUrl match {
      case s if s.startsWith("jdbc:h2") => new H2JobRequestSql()
      case s if s.startsWith("jdbc:postgresql") => new PgJobRequestSql()
      case _ =>
        throw new RuntimeException(s"Can't work with jdbc $jdbcUrl. Supported databses are PostgreSQL and H2");
    }
  }
}

trait JobRequestSql {

//  def flyDbMigrationPath: String

  
  def generateSqlByJobDetailsRequest(req: JobDetailsRequest): Fragment = {
    val filters =
      if (req.filters.isEmpty) sql"" else {
        fr"where" ++ req.filters.map {
          case ByFunctionId(id) => fr"function = $id"
          case ByStatuses(statuses) => Fragments.in(fr"status", statuses.map(_.toString))
          case ByWorkerId(id) => fr"worker_id = $id"
        }.reduce((a, b) => a ++ fr"and" ++ b)
      }
    val limit = fr"limit ${req.limit} offset ${req.offset}"
    val order = fr"order by create_time desc"
    beginSql ++ filters ++ order ++ limit
  }
} 

package io.hydrosphere.mist.master.store

import io.hydrosphere.mist.master.FilterClause.{ByFunctionId, ByStatuses, ByWorkerId}
import io.hydrosphere.mist.master.JobDetails.Status._
import io.hydrosphere.mist.master.{JobDetails, JobDetailsRequest}
import org.scalatest.{FunSpec, Matchers}
import doobie.implicits._
import io.hydrosphere.mist.core.CommonData.{Action, JobParams}
import io.hydrosphere.mist.master.JobDetails.Source
import mist.api.data.JsMap
import cats.data.NonEmptyList

class JobRequestsSqlSpec extends FunSpec with Matchers{

  describe("h2 sql") {
    test(new H2JobRequestSql)
  }
  
  describe("postgres sql") {
    test(new PgJobRequestSql)
  }
  
  def test(jobRequestSql: JobRequestSql): Unit = {
    it("select(*)") {
      val sql = jobRequestSql.generateSqlByJobDetailsRequest(JobDetailsRequest(0, 0))
      sql.toString() shouldEqual sql"select * from job_details order by create_time desc limit ? offset ? ".toString()
    }

    it("filter by function") {
      val sql = jobRequestSql.generateSqlByJobDetailsRequest(JobDetailsRequest(0, 0).withFilter(ByFunctionId("ID")))
      sql.toString() shouldEqual sql"select * from job_details where function = ? order by create_time desc limit ? offset ? ".toString()
    }

    it("filter by worker") {
      val sql = jobRequestSql.generateSqlByJobDetailsRequest(JobDetailsRequest(0, 0).withFilter(ByWorkerId("ID")))
      sql.toString() shouldEqual sql"select * from job_details where worker_id = ? order by create_time desc limit ? offset ? ".toString()
    }

    it("sql filter by status") {
      val sql = jobRequestSql.generateSqlByJobDetailsRequest(JobDetailsRequest(0, 0).withFilter(ByStatuses(NonEmptyList.of(Initialized, Queued))))
      sql.toString() shouldEqual sql"select * from job_details where status IN (?, ?) order by create_time desc limit ? offset ? ".toString()
    }

    it("sql complex filter") {
      val sql = jobRequestSql.generateSqlByJobDetailsRequest(JobDetailsRequest(0, 0).
        withFilter(ByStatuses(NonEmptyList.of(Initialized, Queued))).
        withFilter(ByWorkerId("ID")).
        withFilter(ByFunctionId("ID")))
      sql.toString() shouldEqual sql"select * from job_details where function = ? and worker_id = ? and status IN (?, ?) order by create_time desc limit ? offset ? ".toString()
    }
  }
  
  private def fixtureJobDetails(
    jobId: String,
    status: JobDetails.Status = JobDetails.Status.Initialized): JobDetails = {
    JobDetails(
      params = JobParams("path", "className", JsMap.empty, Action.Execute),
      jobId = jobId,
      source = Source.Http,
      function = "function",
      context = "context",
      externalId = None,
      status = status
    )
  }
  
} 

package com.github.agourlay.cornichon.steps.regular

import cats.data.{ EitherT, NonEmptyList }
import cats.syntax.either._
import com.github.agourlay.cornichon.core._
import com.github.agourlay.cornichon.core.ScenarioRunner._
import monix.eval.Task

import scala.concurrent.duration.Duration
import scala.concurrent.{ ExecutionContext, Future }

case class EffectStep(title: String, effect: ScenarioContext => Future[Either[CornichonError, Session]], show: Boolean = true) extends SessionValueStep {

  def setTitle(newTitle: String): Step = copy(title = newTitle)

  override def runSessionValueStep(runState: RunState): Task[Either[NonEmptyList[CornichonError], Session]] =
    Task.deferFuture(effect(runState.scenarioContext)).map(_.leftMap(NonEmptyList.one))

  override def onError(errors: NonEmptyList[CornichonError], runState: RunState, executionTime: Duration): (LogInstruction, FailedStep) =
    errorsToFailureStep(this, runState.depth, errors, Some(executionTime))

  override def logOnSuccess(result: Session, runState: RunState, executionTime: Duration): LogInstruction =
    successLog(title, runState.depth, show, executionTime)
}

object EffectStep {

  def fromEitherT(title: String, effect: ScenarioContext => EitherT[Future, CornichonError, Session], show: Boolean = true): EffectStep = {
    val effectT: ScenarioContext => Future[Either[CornichonError, Session]] = s => effect(s).value
    EffectStep(title, effectT, show)
  }

  def fromSync(title: String, effect: ScenarioContext => Session, show: Boolean = true): EffectStep = {
    val effectF: ScenarioContext => Future[Either[CornichonError, Session]] = s => Future.successful(effect(s).asRight)
    EffectStep(title, effectF, show)
  }

  def fromSyncE(title: String, effect: ScenarioContext => Either[CornichonError, Session], show: Boolean = true): EffectStep = {
    val effectF: ScenarioContext => Future[Either[CornichonError, Session]] = s => Future.successful(effect(s))
    EffectStep(title, effectF, show)
  }

  def fromAsync(title: String, effect: ScenarioContext => Future[Session], show: Boolean = true)(implicit ec: ExecutionContext): EffectStep = {
    val effectF: ScenarioContext => Future[Either[CornichonError, Session]] = s => effect(s).map(Right.apply)
    EffectStep(title, effectF, show)
  }
} 

package com.github.agourlay.cornichon.steps.wrapped

import cats.data.{ NonEmptyList, StateT }
import com.github.agourlay.cornichon.core._
import com.github.agourlay.cornichon.core.Done._
import monix.eval.Task

case class RetryMaxStep(nested: List[Step], limit: Int) extends WrapperStep {

  require(limit > 0, "retry max limit must be a positive number")

  val title = s"RetryMax block with limit '$limit'"

  override val stateUpdate: StepState = StateT { runState =>

    def retryMaxSteps(runState: RunState, limit: Int, retriesNumber: Long): Task[(Long, RunState, Either[FailedStep, Done])] =
      ScenarioRunner.runStepsShortCircuiting(nested, runState.resetLogStack).flatMap {
        case (retriedState, Left(_)) if limit > 0 =>
          // In case of success all logs are returned but they are not printed by default.
          retryMaxSteps(runState.recordLogStack(retriedState.logStack), limit - 1, retriesNumber + 1)

        case (retriedState, l @ Left(_)) =>
          // In case of failure only the logs of the last run are shown to avoid giant traces.
          Task.now((retriesNumber, retriedState, l))

        case (retriedState, _) =>
          val successState = runState.withSession(retriedState.session).recordLogStack(retriedState.logStack)
          Task.now((retriesNumber, successState, rightDone))

      }

    retryMaxSteps(runState.nestedContext, limit, 0)
      .timed
      .map {
        case (executionTime, run) =>
          val (retries, retriedState, report) = run
          val depth = runState.depth
          val (logStack, res) = report.fold(
            failedStep => {
              val wrappedLogStack = FailureLogInstruction(s"RetryMax block with limit '$limit' failed", depth, Some(executionTime)) +: retriedState.logStack :+ failedTitleLog(depth)
              val artificialFailedStep = FailedStep.fromSingle(failedStep.step, RetryMaxBlockReachedLimit(limit, failedStep.errors))
              (wrappedLogStack, Left(artificialFailedStep))
            },
            _ => {
              val wrappedLogStack = SuccessLogInstruction(s"RetryMax block with limit '$limit' succeeded after '$retries' retries", depth, Some(executionTime)) +: retriedState.logStack :+ successTitleLog(depth)
              (wrappedLogStack, rightDone)
            }
          )
          (runState.mergeNested(retriedState, logStack), res)
      }
  }
}

case class RetryMaxBlockReachedLimit(limit: Int, errors: NonEmptyList[CornichonError]) extends CornichonError {
  lazy val baseErrorMessage = s"Retry max block failed '$limit' times"
  override val causedBy = errors.toList
} 

package com.github.agourlay.cornichon.steps.wrapped

import cats.data.{ NonEmptyList, StateT }
import com.github.agourlay.cornichon.core.Done.rightDone
import com.github.agourlay.cornichon.core._
import monix.eval.Task

case class RepeatWithStep(nested: List[Step], elements: List[String], elementName: String) extends WrapperStep {

  require(elements.nonEmpty, "repeatWith block must contain a non empty sequence of elements")

  val printElements = s"[${elements.mkString(", ")}]"
  val title = s"RepeatWith block with elements $printElements"

  override val stateUpdate: StepState = StateT { runState =>

    def repeatSuccessSteps(remainingElements: List[String], runState: RunState): Task[(RunState, Either[(String, FailedStep), Done])] =
      remainingElements match {
        case Nil =>
          Task.now((runState, rightDone))
        case element :: tail =>
          // reset logs at each loop to have the possibility to not aggregate in failure case
          val rs = runState.resetLogStack
          val runStateWithIndex = rs.addToSession(elementName, element)
          ScenarioRunner.runStepsShortCircuiting(nested, runStateWithIndex).flatMap {
            case (onceMoreRunState, stepResult) =>
              stepResult.fold(
                failed => {
                  // In case of failure only the logs of the last run are shown to avoid giant traces.
                  Task.now((onceMoreRunState, Left((element, failed))))
                },
                _ => {
                  val successState = runState.mergeNested(onceMoreRunState)
                  repeatSuccessSteps(tail, successState)
                }
              )
          }
      }

    repeatSuccessSteps(elements, runState.nestedContext).timed
      .map {
        case (executionTime, (repeatedState, report)) =>
          val depth = runState.depth
          val (logStack, res) = report match {
            case Right(_) =>
              val wrappedLogStack = SuccessLogInstruction(s"RepeatWith block with elements $printElements succeeded", depth, Some(executionTime)) +: repeatedState.logStack :+ successTitleLog(depth)
              (wrappedLogStack, rightDone)
            case Left((failedElement, failedStep)) =>
              val wrappedLogStack = FailureLogInstruction(s"RepeatWith block with elements $printElements failed at element '$failedElement'", depth, Some(executionTime)) +: repeatedState.logStack :+ failedTitleLog(depth)
              val artificialFailedStep = FailedStep.fromSingle(failedStep.step, RepeatWithBlockContainFailedSteps(failedElement, failedStep.errors))
              (wrappedLogStack, Left(artificialFailedStep))
          }
          (runState.mergeNested(repeatedState, logStack), res)
      }
  }
}

case class RepeatWithBlockContainFailedSteps(element: String, errors: NonEmptyList[CornichonError]) extends CornichonError {
  lazy val baseErrorMessage = s"RepeatWith block failed for element '$element'"
  override val causedBy = errors.toList
} 

package com.github.agourlay.cornichon.steps.wrapped

import cats.data.{ NonEmptyList, StateT }
import com.github.agourlay.cornichon.core._
import com.github.agourlay.cornichon.json.CornichonJson
import com.github.agourlay.cornichon.core.ScenarioRunner._
import com.github.agourlay.cornichon.core.Done._
import com.github.agourlay.cornichon.util.Printing._
import monix.eval.Task

case class WithDataInputStep(nested: List[Step], where: String) extends WrapperStep {

  val title = s"With data input block $where"

  override val stateUpdate: StepState = StateT { runState =>

    def runInputs(inputs: List[List[(String, String)]], runState: RunState): Task[(RunState, Either[(List[(String, String)], FailedStep), Done])] =
      if (inputs.isEmpty) Task.now((runState, rightDone))
      else {
        val currentInputs = inputs.head
        val runInfo = InfoLogInstruction(s"Run with inputs ${printArrowPairs(currentInputs)}", runState.depth)
        val bootstrapFilledInput = runState.addToSession(currentInputs).withLog(runInfo).goDeeper
        ScenarioRunner.runStepsShortCircuiting(nested, bootstrapFilledInput).flatMap {
          case (filledState, stepsResult) =>
            stepsResult.fold(
              failedStep => {
                // Prepend previous logs
                Task.now((runState.mergeNested(filledState), Left((currentInputs, failedStep))))
              },
              _ => {
                // Logs are propagated but not the session
                runInputs(inputs.tail, runState.recordLogStack(filledState.logStack))
              }
            )
        }
      }

    runState.scenarioContext.fillPlaceholders(where)
      .flatMap(CornichonJson.parseDataTable)
      .fold(
        t => Task.now(handleErrors(this, runState, NonEmptyList.one(t))),
        parsedTable => {
          val inputs = parsedTable.map { line =>
            line.toList.map { case (key, json) => (key, CornichonJson.jsonStringValue(json)) }
          }

          runInputs(inputs, runState.nestedContext)
            .timed
            .map {
              case (executionTime, (inputsState, inputsRes)) =>
                val initialDepth = runState.depth
                val (logStack, res) = inputsRes match {
                  case Right(_) =>
                    val wrappedLogStack = SuccessLogInstruction("With data input succeeded for all inputs", initialDepth, Some(executionTime)) +: inputsState.logStack :+ successTitleLog(initialDepth)
                    (wrappedLogStack, rightDone)
                  case Left((failedInputs, failedStep)) =>
                    val wrappedLogStack = FailureLogInstruction("With data input failed for one input", initialDepth, Some(executionTime)) +: inputsState.logStack :+ failedTitleLog(initialDepth)
                    val artificialFailedStep = FailedStep.fromSingle(failedStep.step, WithDataInputBlockFailedStep(failedInputs, failedStep.errors))
                    (wrappedLogStack, Left(artificialFailedStep))
                }
                (runState.mergeNested(inputsState, logStack), res)
            }
        }
      )
  }
}

case class WithDataInputBlockFailedStep(failedInputs: List[(String, String)], errors: NonEmptyList[CornichonError]) extends CornichonError {
  lazy val baseErrorMessage = s"WithDataInput block failed for inputs ${printArrowPairs(failedInputs)}"
  override val causedBy = errors.toList
} 

package com.github.agourlay.cornichon.steps.wrapped

import cats.data.{ NonEmptyList, StateT }
import com.github.agourlay.cornichon.core._
import com.github.agourlay.cornichon.core.Done._
import monix.eval.Task

case class RepeatStep(nested: List[Step], occurrence: Int, indexName: Option[String]) extends WrapperStep {

  require(occurrence > 0, "repeat block must contain a positive number of occurrence")

  val title = s"Repeat block with occurrence '$occurrence'"

  override val stateUpdate: StepState = StateT { runState =>

    def repeatSuccessSteps(retriesNumber: Int, runState: RunState): Task[(Int, RunState, Either[FailedStep, Done])] = {
      // reset logs at each loop to have the possibility to not aggregate in failure case
      val rs = runState.resetLogStack
      val runStateWithIndex = indexName.fold(rs)(in => rs.addToSession(in, (retriesNumber + 1).toString))
      ScenarioRunner.runStepsShortCircuiting(nested, runStateWithIndex).flatMap {
        case (onceMoreRunState, stepResult) =>
          stepResult.fold(
            failed => {
              // In case of failure only the logs of the last run are shown to avoid giant traces.
              Task.now((retriesNumber, onceMoreRunState, Left(failed)))
            },
            _ => {
              val successState = runState.withSession(onceMoreRunState.session).recordLogStack(onceMoreRunState.logStack)
              // only show last successful run to avoid giant traces.
              if (retriesNumber == occurrence - 1) Task.now((retriesNumber, successState, rightDone))
              else repeatSuccessSteps(retriesNumber + 1, runState.withSession(onceMoreRunState.session))
            }
          )
      }
    }

    repeatSuccessSteps(0, runState.nestedContext)
      .timed
      .map {
        case (executionTime, run) =>
          val (retries, repeatedState, report) = run
          val depth = runState.depth
          val (logStack, res) = report.fold(
            failedStep => {
              val wrappedLogStack = FailureLogInstruction(s"Repeat block with occurrence '$occurrence' failed after '$retries' occurrence", depth, Some(executionTime)) +: repeatedState.logStack :+ failedTitleLog(depth)
              val artificialFailedStep = FailedStep.fromSingle(failedStep.step, RepeatBlockContainFailedSteps(retries, failedStep.errors))
              (wrappedLogStack, Left(artificialFailedStep))
            },
            _ => {
              val wrappedLockStack = SuccessLogInstruction(s"Repeat block with occurrence '$occurrence' succeeded", depth, Some(executionTime)) +: repeatedState.logStack :+ successTitleLog(depth)
              (wrappedLockStack, rightDone)
            }
          )
          (runState.mergeNested(repeatedState, logStack), res)
      }
  }
}

case class RepeatBlockContainFailedSteps(failedOccurrence: Int, errors: NonEmptyList[CornichonError]) extends CornichonError {
  lazy val baseErrorMessage = s"Repeat block failed at occurrence $failedOccurrence"
  override val causedBy = errors.toList
} 

package com.github.agourlay.cornichon.steps.wrapped

import java.util.concurrent.TimeUnit

import cats.data.{ NonEmptyList, StateT }
import com.github.agourlay.cornichon.core._
import com.github.agourlay.cornichon.core.Done._
import monix.eval.Task

import scala.concurrent.duration.FiniteDuration

case class RepeatDuringStep(nested: List[Step], duration: FiniteDuration) extends WrapperStep {

  val title = s"Repeat block during '$duration'"

  override val stateUpdate: StepState = StateT { runState =>
    val initialDepth = runState.depth

    def repeatStepsDuring(runState: RunState, duration: FiniteDuration, retriesNumber: Long): Task[(Long, RunState, Either[FailedStep, Done])] =
      ScenarioRunner.runStepsShortCircuiting(nested, runState.resetLogStack) // reset logs at each loop to have the possibility to not aggregate in failure case
        .timed
        .flatMap {
          case (executionTime, run) =>
            val (repeatedOnceMore, res) = run
            val remainingTime = duration - executionTime
            res.fold(
              failedStep => {
                // In case of failure only the logs of the last run are shown to avoid giant traces.
                Task.now((retriesNumber, repeatedOnceMore, Left(failedStep)))
              },
              _ => {
                val successState = runState.mergeNested(repeatedOnceMore)
                if (remainingTime.gt(FiniteDuration(0, TimeUnit.MILLISECONDS)))
                  repeatStepsDuring(successState, remainingTime, retriesNumber + 1)
                else
                  // In case of success all logs are returned but they are not printed by default.
                  Task.now((retriesNumber, successState, rightDone))
              }
            )
        }

    repeatStepsDuring(runState.nestedContext, duration, 0)
      .timed
      .map {
        case (executionTime, run) =>
          val (retries, repeatedRunState, report) = run
          val (logStack, res) = report.fold(
            failedStep => {
              val wrappedLogStack = FailureLogInstruction(s"Repeat block during '$duration' failed after being retried '$retries' times", initialDepth, Some(executionTime)) +: repeatedRunState.logStack :+ failedTitleLog(initialDepth)
              val artificialFailedStep = FailedStep.fromSingle(failedStep.step, RepeatDuringBlockContainFailedSteps(duration, failedStep.errors))
              (wrappedLogStack, Left(artificialFailedStep))
            },
            _ => {
              val wrappedLogStack = SuccessLogInstruction(s"Repeat block during '$duration' succeeded after '$retries' retries", initialDepth, Some(executionTime)) +: repeatedRunState.logStack :+ successTitleLog(initialDepth)
              (wrappedLogStack, rightDone)
            }
          )
          (runState.mergeNested(repeatedRunState, logStack), res)
      }
  }
}

case class RepeatDuringBlockContainFailedSteps(duration: FiniteDuration, errors: NonEmptyList[CornichonError]) extends CornichonError {
  lazy val baseErrorMessage = s"RepeatDuring block failed before '$duration'"
  override val causedBy = errors.toList
} 

package com.github.agourlay.cornichon.steps.cats

import cats.data.{ EitherT, NonEmptyList }
import cats.effect.Effect
import cats.syntax.either._
import com.github.agourlay.cornichon.core.ScenarioRunner.{ errorsToFailureStep, successLog }
import com.github.agourlay.cornichon.core._
import monix.eval.Task
import monix.execution.Scheduler

import scala.concurrent.duration.Duration

case class EffectStep[F[_]: Effect](title: String, effect: ScenarioContext => F[Either[CornichonError, Session]], show: Boolean = true) extends SessionValueStep {

  def setTitle(newTitle: String): Step = copy(title = newTitle)

  override def runSessionValueStep(runState: RunState): Task[Either[NonEmptyList[CornichonError], Session]] =
    Task.fromEffect(effect(runState.scenarioContext)).map(_.leftMap(NonEmptyList.one))

  override def onError(errors: NonEmptyList[CornichonError], runState: RunState, executionTime: Duration): (LogInstruction, FailedStep) =
    errorsToFailureStep(this, runState.depth, errors, Some(executionTime))

  override def logOnSuccess(result: Session, runState: RunState, executionTime: Duration): LogInstruction =
    successLog(title, runState.depth, show, executionTime)

}

object EffectStep {

  def fromEitherT[F[_]: Effect](title: String, effect: ScenarioContext => EitherT[F, CornichonError, Session], show: Boolean = true): Step = {
    val effectT: ScenarioContext => F[Either[CornichonError, Session]] = s => effect(s).value
    EffectStep(title, effectT, show)
  }

  def fromSync(title: String, effect: ScenarioContext => Session, show: Boolean = true): Step = {
    import Scheduler.Implicits.global
    val effectF: ScenarioContext => Task[Either[CornichonError, Session]] = s => Task.now(effect(s).asRight)
    EffectStep(title, effectF, show)
  }

  def fromSyncE(title: String, effect: ScenarioContext => Either[CornichonError, Session], show: Boolean = true): Step = {
    import Scheduler.Implicits.global
    val effectF: ScenarioContext => Task[Either[CornichonError, Session]] = s => Task.now(effect(s))
    EffectStep(title, effectF, show)
  }

  def fromAsync[F[_]: Effect](title: String, effect: ScenarioContext => F[Session], show: Boolean = true): Step = {
    import Scheduler.Implicits.global
    val effectF: ScenarioContext => Task[Either[CornichonError, Session]] = s => Task.fromEffect(effect(s)).map(Right.apply)
    EffectStep(title, effectF, show)
  }

} 

package com.github.agourlay.cornichon.core

import cats.data.Validated.Valid
import cats.data.{ NonEmptyList, ValidatedNel }
import cats.kernel.Monoid
import monix.eval.Task

import scala.concurrent.Future
import scala.concurrent.duration.{ Duration, FiniteDuration }

sealed trait ScenarioReport {
  def isSuccess: Boolean
  def scenarioName: String
  def session: Session
  def logs: List[LogInstruction]
  def duration: FiniteDuration
}

object ScenarioReport {
  def build(scenarioName: String, runState: RunState, result: ValidatedNel[FailedStep, Done], duration: FiniteDuration): ScenarioReport =
    result.fold(
      failedSteps => FailureScenarioReport(scenarioName, failedSteps, runState.session, runState.logStack, duration, runState.randomContext.initialSeed),
      _ => SuccessScenarioReport(scenarioName, runState.session, runState.logStack, duration, runState.randomContext.initialSeed)
    )
}

case class SuccessScenarioReport(scenarioName: String, session: Session, logStack: List[LogInstruction], duration: FiniteDuration, seed: Long) extends ScenarioReport {
  val isSuccess = true

  // keeping it lazy to avoid the reverse in case of no rendering
  lazy val logs = logStack.reverse
  // In case of success, logs are only shown if the scenario contains DebugLogInstruction
  lazy val shouldShowLogs: Boolean = logStack.exists(_.isInstanceOf[DebugLogInstruction])
}

case class IgnoreScenarioReport(scenarioName: String, reason: String, session: Session) extends ScenarioReport {
  val logs = Nil
  val isSuccess = false
  val duration = Duration.Zero
}

case class PendingScenarioReport(scenarioName: String, session: Session) extends ScenarioReport {
  val logs = Nil
  val isSuccess = false
  val duration = Duration.Zero
}

case class FailureScenarioReport(scenarioName: String, failedSteps: NonEmptyList[FailedStep], session: Session, logStack: List[LogInstruction], duration: FiniteDuration, seed: Long) extends ScenarioReport {
  val isSuccess = false

  val msg =
    s"""|Scenario '$scenarioName' failed:
        |${failedSteps.toList.iterator.map(_.messageForFailedStep).mkString("\nand\n")}
        |seed for the run was '$seed'
        |""".stripMargin

  lazy val logs = logStack.reverse
  lazy val renderedColoredLogs = LogInstruction.renderLogs(logs)
  lazy val renderedLogs = LogInstruction.renderLogs(logs, colorized = false)
}

sealed abstract class Done
case object Done extends Done {
  val rightDone = Right(Done)
  val validDone = Valid(Done)
  val futureDone = Future.successful(Done)
  val taskDone = Task.now(Done)
  implicit val monoid = new Monoid[Done] {
    def empty: Done = Done
    def combine(x: Done, y: Done): Done = x
  }
}

case class FailedStep(step: Step, errors: NonEmptyList[CornichonError]) {
  lazy val messageForFailedStep =
    s"""
       |at step:
       |${step.title}
       |
       |with error(s):
       |${errors.toList.iterator.map(_.renderedMessage).mkString("\nand\n")}
       |""".stripMargin

}

object FailedStep {
  def fromSingle(step: Step, error: CornichonError) = FailedStep(step, NonEmptyList.one(error))
} 

package tofu.optics

import cats._
import cats.data.NonEmptyList
import tofu.optics.data.Constant
import cats.syntax.semigroup._


trait PReduced[-S, +T, +A, -B] extends PFolded[S, T, A, B] { self =>
  def reduceMap[X: Semigroup](s: S)(f: A => X): X

  override def foldMap[X: Monoid](s: S)(f: A => X): X = reduceMap(s)(f)
  def getAll1(s: S): NonEmptyList[A]                  = reduceMap(s)(NonEmptyList.one[A])

  def +++[S1 <: S, A1 >: A](other: PReduced[S1, Any, A1, Nothing]): PReduced[S1, T, A1, B] =
    new PReduced[S1, T, A1, B] {
      override def reduceMap[X: Semigroup](s: S1)(f: A1 => X): X =
        self.reduceMap(s)(f) |+| other.reduceMap(s)(f)
    }
}

object Reduced extends MonoOpticCompanion(PReduced) {
  def apply[S] = new ReducedApply[S]

  class ReducedApply[S] {
    type Arb

    def apply[A](fm: Semigroup[Arb] => (S, A => Arb) => Arb): Reduced[S, A] = new Reduced[S, A] {
      def reduceMap[X: Semigroup](s: S)(f: A => X): X =
        fm(Semigroup[X].asInstanceOf[Semigroup[Arb]])(s, f.asInstanceOf[A => Arb]).asInstanceOf[X]
    }
  }
}

object PReduced extends OpticCompanion[PReduced] {
  def compose[S, T, A, B, U, V](f: PReduced[A, B, U, V], g: PReduced[S, T, A, B]): PReduced[S, T, U, V] =
    new PReduced[S, T, U, V] {
      def reduceMap[X: Semigroup](s: S)(fux: U => X): X = g.reduceMap(s)(f.reduceMap(_)(fux))
    }

  final implicit def byReducible[F[_], T, A, B](implicit F: Reducible[F]): PReduced[F[A], T, A, B] =
    new PReduced[F[A], T, A, B] {
      def reduceMap[X: Semigroup](fa: F[A])(f: A => X): X = F.reduceMap(fa)(f)
    }

  trait Context extends PRepeated.Context with PExtract.Context {
    def algebra: Semigroup[X]
    override def functor: Apply[Constant[X, *]] = {
      implicit val alg: Semigroup[X] = algebra
      Apply[Constant[X, *]]
    }
  }

  override def toGeneric[S, T, A, B](o: PReduced[S, T, A, B]): Optic[Context, S, T, A, B]   =
    new Optic[Context, S, T, A, B] {
      def apply(c: Context)(p: A => Constant[c.X, B]): S => Constant[c.X, T] =
        s => Constant.Impl(o.reduceMap(s)(a => p(a).value)(c.algebra))
    }
  override def fromGeneric[S, T, A, B](o: Optic[Context, S, T, A, B]): PReduced[S, T, A, B] =
    new PReduced[S, T, A, B] {
      def reduceMap[Y: Semigroup](s: S)(f: A => Y): Y =
        o.apply(new Context {
            type X = Y
            def algebra = Semigroup[Y]
          })(a => Constant.Impl(f(a)))(s)
          .value

    }
} 

package tofu.optics
import cats.data.NonEmptyList
import cats.kernel.Semigroup
import cats.{Applicative, Apply, Monoid}
import tofu.optics.classes.Category2
import tofu.optics.tags.{PTagApply, Tagger}

final case class Applied[O[_, _, _, _], S, T, A, B](s: S, o: O[S, T, A, B]) {
  def >>[O1[s, t, a, b] >: O[s, t, a, b]: Category2, U, V](o1: O1[A, B, U, V]): Applied[O1, S, T, U, V] =
    Applied(s, Category2.compose(o1, o))

  def >[O1[s, t, a, b] >: O[s, t, a, b]](tagger: Tagger[O1]): AppliedWithTag[O1, S, T, A, B, tagger.Tag] =
    AppliedWithTag(s, o)

  def put(b: B)(implicit ev: O[S, T, A, B] <:< PUpdate[S, T, A, B]): T = ev(o).put(s, b)

  def update(f: A => B)(implicit ev: O[S, T, A, B] <:< PUpdate[S, T, A, B]): T = ev(o).update(s, f)

  def get(implicit ev: O[S, T, A, B] <:< PExtract[S, T, A, B]): A = ev(o).extract(s)

  def downcast(implicit ev: O[S, T, A, B] <:< PDowncast[S, T, A, B]): Option[A] = ev(o).downcast(s)

  def traverse[G[+_]: Applicative](f: A => G[B])(implicit ev: O[S, T, A, B] <:< PItems[S, T, A, B]): G[T] =
    ev(o).traverse(s)(f)

  def foldMap[M: Monoid](f: A => M)(implicit ev: O[S, T, A, B] <:< PFolded[S, T, A, B]): M =
    ev(o).foldMap(s)(f)

  def reduceMap[M: Semigroup](f: A => M)(implicit ev: O[S, T, A, B] <:< PReduced[S, T, A, B]): M =
    ev(o).reduceMap(s)(f)

  def getAll1(implicit ev: O[S, T, A, B] <:< PReduced[S, T, A, B]): NonEmptyList[A] =
    ev(o).getAll1(s)

  def getAll(implicit ev: O[S, T, A, B] <:< PFolded[S, T, A, B]): List[A] =
    ev(o).getAll(s)

  def traverse1[G[+_]: Apply](f: A => G[B])(implicit ev: O[S, T, A, B] <:< PRepeated[S, T, A, B]): G[T] =
    ev(o).traverse1(s)(f)
}

final case class AppliedWithTag[O[_, _, _, _], S, T, A, B, Tag](s: S, o: O[S, T, A, B]) {
  def >@[X, U, V](x: X)(implicit tag: PTagApply[O, A, B, U, V, Tag, X], cat: Category2[O]): Applied[O, S, T, U, V] =
    Applied(s, cat.compose(tag.continue(x), o))

  def >[O1[s, t, a, b] >: O[s, t, a, b], U, V](
      tagger: Tagger[O1]
  )(implicit tag: PTagApply[O, A, B, U, V, Tag, Unit], cat: Category2[O]): AppliedWithTag[O1, S, T, U, V, tagger.Tag] =
    end > tagger

  def >>[O1[s, t, a, b] >: O[s, t, a, b]: Category2, U, V, X, Y](o1: O1[U, V, X, Y])(implicit
      tag: PTagApply[O, A, B, U, V, Tag, Unit],
      cat: Category2[O]
  ): Applied[O1, S, T, X, Y] =
    end >> o1

  def end[U, V](implicit tag: PTagApply[O, A, B, U, V, Tag, Unit], cat: Category2[O]): Applied[O, S, T, U, V] =
    >@ {}
}

object chain {
  def to[T]          = new ChainTo[T]
  def apply[S](s: S) = Applied(s, PSame.id[S, S])

  class ChainTo[T] {
    def apply[S](s: S) = Applied(s, PSame.id[S, T])
  }
} 

package tofu
package config

import cats.data.NonEmptyList
import tofu.config.ConfigItem.ValueTag
import cats.Show
import cats.syntax.show._
import cats.syntax.foldable._
import cats.instances.string._
import cats.instances.vector._

sealed trait ConfigError extends Product with Serializable
object ConfigError {
  case object NotFound                                                 extends ConfigError
  case object NoVariantFound                                           extends ConfigError
  final case class BadType(expected: List[ValueTag], actual: ValueTag) extends ConfigError
  final case class BadNumber(value: BigDecimal, message: String)       extends ConfigError
  final case class BadString(value: String, message: String)           extends ConfigError
  final case class Invalid(message: String)                            extends ConfigError
  final case class MultipleVariants(variants: NonEmptyList[String])    extends ConfigError

  implicit val configErrorShow: Show[ConfigError] = {
    case NotFound                   => "not found"
    case NoVariantFound             => "no variant found"
    case BadType(expected, actual)  => s"bad type, expected: ${expected.mkString(",")}, actual : $actual"
    case BadNumber(value, message)  => s"bad number $value : $message"
    case BadString(value, message)  => s"bad string '$value' : $message"
    case MultipleVariants(variants) => s"multiple variants found : $variants"
    case Invalid(message)           => message
  }
}

final case class ConfigParseMessage(path: Path, error: ConfigError)

object ConfigParseMessage {
  implicit val messageShow: Show[ConfigParseMessage] = message => {
    val pathShown = message.path.iterator.map(_.show).mkString(".")
    show"$pathShown : ${message.error}"
  }
}

final case class ConfigParseErrors(ms: MessageList) extends RuntimeException(ms.mkString_("\n")) 

package gospeak.infra.services.storage.sql

import java.time.Instant

import cats.data.NonEmptyList
import cats.effect.IO
import doobie.implicits._
import gospeak.core.domain._
import gospeak.core.domain.utils.{Info, UserAwareCtx, UserCtx}
import gospeak.core.services.storage.ExternalCfpRepo
import gospeak.infra.services.storage.sql.ExternalCfpRepoSql._
import gospeak.infra.services.storage.sql.utils.DoobieUtils.Mappings._
import gospeak.infra.services.storage.sql.utils.DoobieUtils._
import gospeak.infra.services.storage.sql.utils.GenericRepo
import gospeak.libs.scala.Extensions._
import gospeak.libs.scala.domain.{Done, Page}

class ExternalCfpRepoSql(protected[sql] val xa: doobie.Transactor[IO]) extends GenericRepo with ExternalCfpRepo {
  override def create(event: ExternalEvent.Id, data: ExternalCfp.Data)(implicit ctx: UserCtx): IO[ExternalCfp] =
    insert(ExternalCfp(data, event, Info(ctx.user.id, ctx.now))).run(xa)

  override def edit(cfp: ExternalCfp.Id)(data: ExternalCfp.Data)(implicit ctx: UserCtx): IO[Done] =
    update(cfp)(data, ctx.user.id, ctx.now).run(xa)

  override def listAllIds(): IO[Seq[ExternalCfp.Id]] = selectAllIds().runList(xa)

  override def listAll(event: ExternalEvent.Id): IO[Seq[ExternalCfp]] = selectAll(event).runList(xa)

  override def listIncoming(params: Page.Params)(implicit ctx: UserAwareCtx): IO[Page[CommonCfp]] = selectCommonPageIncoming(params).run(xa)

  override def listDuplicatesFull(p: ExternalCfp.DuplicateParams): IO[Seq[ExternalCfp.Full]] = selectDuplicatesFull(p).runList(xa)

  override def findFull(cfp: ExternalCfp.Id): IO[Option[ExternalCfp.Full]] = selectOneFull(cfp).runOption(xa)

  override def findCommon(cfp: Cfp.Slug): IO[Option[CommonCfp]] = selectOneCommon(cfp).runOption(xa)

  override def findCommon(cfp: ExternalCfp.Id): IO[Option[CommonCfp]] = selectOneCommon(cfp).runOption(xa)
}

object ExternalCfpRepoSql {
  private val _ = externalCfpIdMeta // for intellij not remove DoobieUtils.Mappings import
  private val table = Tables.externalCfps
  private val tableFull = table
    .join(Tables.externalEvents.dropFields(_.name.startsWith("location_")), _.event_id -> _.id).get
  private val commonTable = Table(
    name = "((SELECT c.name, g.logo, c.begin, c.close, g.location, c.description, c.tags, null as ext_id, null  as ext_url, null    as ext_event_start, null     as ext_event_finish, null  as ext_event_url, null          as ext_tickets_url, null         as ext_videos_url, null as twitter_account, null as twitter_hashtag, c.slug as int_slug, g.id as group_id, g.slug as group_slug FROM cfps c INNER JOIN groups g ON c.group_id=g.id) " +
      "UNION (SELECT e.name, e.logo, c.begin, c.close, e.location, c.description, e.tags, c.id as ext_id, c.url as ext_url, e.start as ext_event_start, e.finish as ext_event_finish, e.url as ext_event_url, e.tickets_url as ext_tickets_url, e.videos_url as ext_videos_url,       e.twitter_account,       e.twitter_hashtag, null   as int_slug, null as group_id,   null as group_slug FROM external_cfps c INNER JOIN external_events e ON c.event_id=e.id))",
    prefix = "c",
    joins = Seq(),
    fields = Seq(
      "name", "logo", "begin", "close", "location", "description", "tags",
      "ext_id", "ext_url", "ext_event_start", "ext_event_finish", "ext_event_url", "ext_tickets_url", "ext_videos_url", "twitter_account", "twitter_hashtag",
      "int_slug", "group_id", "group_slug").map(Field(_, "c")),
    aggFields = Seq(),
    customFields = Seq(),
    sorts = Sorts("close", "close date", Field("close", "c"), Field("name", "c")),
    search = Seq("name", "description", "tags").map(Field(_, "c")),
    filters = Seq())

  private[sql] def insert(e: ExternalCfp): Insert[ExternalCfp] = {
    val values = fr0"${e.id}, ${e.event}, ${e.description}, ${e.begin}, ${e.close}, ${e.url}, ${e.info.createdAt}, ${e.info.createdBy}, ${e.info.updatedAt}, ${e.info.updatedBy}"
    table.insert[ExternalCfp](e, _ => values)
  }

  private[sql] def update(id: ExternalCfp.Id)(e: ExternalCfp.Data, by: User.Id, now: Instant): Update = {
    val fields = fr0"description=${e.description}, begin=${e.begin}, close=${e.close}, url=${e.url}, updated_at=$now, updated_by=$by"
    table.update(fields, fr0"WHERE id=$id")
  }

  private[sql] def selectAllIds(): Select[ExternalCfp.Id] =
    table.select[ExternalCfp.Id](Seq(Field("id", "ec")))

  private[sql] def selectAll(id: ExternalEvent.Id): Select[ExternalCfp] =
    table.select[ExternalCfp](fr0"WHERE ec.event_id=$id")

  private[sql] def selectOneFull(id: ExternalCfp.Id): Select[ExternalCfp.Full] =
    tableFull.selectOne[ExternalCfp.Full](fr0"WHERE ec.id=$id")

  private[sql] def selectOneCommon(slug: Cfp.Slug): Select[CommonCfp] =
    commonTable.selectOne[CommonCfp](fr0"WHERE c.slug=$slug")

  private[sql] def selectOneCommon(id: ExternalCfp.Id): Select[CommonCfp] =
    commonTable.selectOne[CommonCfp](fr0"WHERE c.id=$id")

  private[sql] def selectCommonPageIncoming(params: Page.Params)(implicit ctx: UserAwareCtx): SelectPage[CommonCfp, UserAwareCtx] =
    commonTable.selectPage[CommonCfp, UserAwareCtx](params, fr0"WHERE (c.close IS NULL OR c.close >= ${ctx.now})")

  private[sql] def selectDuplicatesFull(p: ExternalCfp.DuplicateParams): Select[ExternalCfp.Full] = {
    val filters = Seq(
      p.cfpUrl.map(v => fr0"ec.url LIKE ${"%" + v + "%"}"),
      p.cfpEndDate.map(v => fr0"ec.close=$v")
    ).flatten
    if (filters.isEmpty) {
      tableFull.select[ExternalCfp.Full](fr0"WHERE ec.id='no-match'")
    } else {
      tableFull.select[ExternalCfp.Full](fr0"WHERE " ++ filters.reduce(_ ++ fr0" OR " ++ _))
    }
  }
} 

package gospeak.infra.services.storage.sql

import java.time.Instant

import cats.data.NonEmptyList
import cats.effect.IO
import doobie.Fragments
import doobie.implicits._
import doobie.util.fragment.Fragment
import gospeak.core.domain.utils.OrgaCtx
import gospeak.core.domain.{Group, SponsorPack, User}
import gospeak.core.services.storage.SponsorPackRepo
import gospeak.infra.services.storage.sql.SponsorPackRepoSql._
import gospeak.infra.services.storage.sql.utils.DoobieUtils.Mappings._
import gospeak.infra.services.storage.sql.utils.DoobieUtils.{Insert, Select, Update}
import gospeak.infra.services.storage.sql.utils.GenericRepo
import gospeak.libs.scala.domain.{CustomException, Done}

class SponsorPackRepoSql(protected[sql] val xa: doobie.Transactor[IO]) extends GenericRepo with SponsorPackRepo {
  override def create(data: SponsorPack.Data)(implicit ctx: OrgaCtx): IO[SponsorPack] =
    insert(SponsorPack(ctx.group.id, data, ctx.info)).run(xa)

  override def edit(pack: SponsorPack.Slug, data: SponsorPack.Data)(implicit ctx: OrgaCtx): IO[Done] = {
    if (data.slug != pack) {
      find(data.slug).flatMap {
        case None => update(ctx.group.id, pack)(data, ctx.user.id, ctx.now).run(xa)
        case _ => IO.raiseError(CustomException(s"You already have a sponsor pack with slug ${data.slug}"))
      }
    } else {
      update(ctx.group.id, pack)(data, ctx.user.id, ctx.now).run(xa)
    }
  }

  override def disable(pack: SponsorPack.Slug)(implicit ctx: OrgaCtx): IO[Done] =
    setActive(ctx.group.id, pack)(active = false, ctx.user.id, ctx.now).run(xa)

  override def enable(pack: SponsorPack.Slug)(implicit ctx: OrgaCtx): IO[Done] =
    setActive(ctx.group.id, pack)(active = true, ctx.user.id, ctx.now).run(xa)

  override def find(pack: SponsorPack.Slug)(implicit ctx: OrgaCtx): IO[Option[SponsorPack]] = selectOne(ctx.group.id, pack).runOption(xa)

  override def listAll(group: Group.Id): IO[Seq[SponsorPack]] = selectAll(group).runList(xa)

  override def listAll(implicit ctx: OrgaCtx): IO[Seq[SponsorPack]] = selectAll(ctx.group.id).runList(xa)

  override def listActives(group: Group.Id): IO[Seq[SponsorPack]] = selectActives(group).runList(xa)

  override def listActives(implicit ctx: OrgaCtx): IO[Seq[SponsorPack]] = selectActives(ctx.group.id).runList(xa)
}

object SponsorPackRepoSql {
  private val _ = sponsorPackIdMeta // for intellij not remove DoobieUtils.Mappings import
  private val table = Tables.sponsorPacks

  private[sql] def insert(e: SponsorPack): Insert[SponsorPack] = {
    val values = fr0"${e.id}, ${e.group}, ${e.slug}, ${e.name}, ${e.description}, ${e.price.amount}, ${e.price.currency}, ${e.duration}, ${e.active}, ${e.info.createdAt}, ${e.info.createdBy}, ${e.info.updatedAt}, ${e.info.updatedBy}"
    table.insert(e, _ => values)
  }

  private[sql] def update(group: Group.Id, pack: SponsorPack.Slug)(data: SponsorPack.Data, by: User.Id, now: Instant): Update = {
    val fields = fr0"slug=${data.slug}, name=${data.name}, description=${data.description}, price=${data.price.amount}, currency=${data.price.currency}, duration=${data.duration}, updated_at=$now, updated_by=$by"
    table.update(fields, where(group, pack))
  }

  private[sql] def setActive(group: Group.Id, pack: SponsorPack.Slug)(active: Boolean, by: User.Id, now: Instant): Update =
    table.update(fr0"active=$active, updated_at=$now, updated_by=$by", where(group, pack))

  private[sql] def selectOne(group: Group.Id, pack: SponsorPack.Slug): Select[SponsorPack] =
    table.select[SponsorPack](where(group, pack))

  private[sql] def selectAll(ids: NonEmptyList[SponsorPack.Id]): Select[SponsorPack] =
    table.select[SponsorPack](fr0"WHERE " ++ Fragments.in(fr"sp.id", ids))

  private[sql] def selectAll(group: Group.Id): Select[SponsorPack] =
    table.select[SponsorPack](where(group))

  private[sql] def selectActives(group: Group.Id): Select[SponsorPack] = {
    val active = true
    table.select[SponsorPack](where(group) ++ fr0" AND sp.active=$active")
  }

  private def where(group: Group.Id, slug: SponsorPack.Slug): Fragment =
    fr0"WHERE sp.group_id=$group AND sp.slug=$slug"

  private def where(group: Group.Id): Fragment =
    fr0"WHERE sp.group_id=$group"
} 

package gospeak.infra.services.storage.sql

import cats.data.NonEmptyList
import gospeak.infra.services.storage.sql.ContactRepoSqlSpec.{fields => contactFields, table => contactTable}
import gospeak.infra.services.storage.sql.EventRepoSqlSpec.{table => eventTable}
import gospeak.infra.services.storage.sql.GroupRepoSqlSpec.{table => groupTable}
import gospeak.infra.services.storage.sql.PartnerRepoSqlSpec.{fields => partnerFields, table => partnerTable}
import gospeak.infra.services.storage.sql.VenueRepoSqlSpec._
import gospeak.infra.services.storage.sql.testingutils.RepoSpec

class VenueRepoSqlSpec extends RepoSpec {
  describe("VenueRepoSql") {
    describe("Queries") {
      it("should build insert") {
        val q = VenueRepoSql.insert(venue)
        check(q, s"INSERT INTO ${table.stripSuffix(" v")} (${mapFields(fieldsInsert, _.stripPrefix("v."))}) VALUES (${mapFields(fieldsInsert, _ => "?")})")
      }
      it("should build update") {
        val q = VenueRepoSql.update(group.id, venue.id)(venue.data, user.id, now)
        check(q, s"UPDATE $table SET contact_id=?, address=?, address_id=?, address_lat=?, address_lng=?, address_locality=?, address_country=?, notes=?, room_size=?, meetupGroup=?, meetupVenue=?, updated_at=?, updated_by=? WHERE v.id=(SELECT v.id FROM $tableFull WHERE pa.group_id=? AND v.id=? $orderByFull)")
      }
      it("should build delete") {
        val q = VenueRepoSql.delete(group.id, venue.id)
        check(q, s"DELETE FROM $table WHERE v.id=(SELECT v.id FROM $tableFull WHERE pa.group_id=? AND v.id=? $orderByFull)")
      }
      it("should build selectOneFull") {
        val q = VenueRepoSql.selectOneFull(venue.id)
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE v.id=? $orderBy")
      }
      it("should build selectOneFull in a group") {
        val q = VenueRepoSql.selectOneFull(group.id, venue.id)
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE pa.group_id=? AND v.id=? $orderBy")
      }
      it("should build selectPageFull") {
        val q = VenueRepoSql.selectPageFull(params)
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE pa.group_id=? $orderBy LIMIT 20 OFFSET 0")
      }
      it("should build selectAllFull for group id") {
        val q = VenueRepoSql.selectAllFull(group.id)
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE pa.group_id=? $orderBy")
      }
      it("should build selectAllFull for partner id") {
        val q = VenueRepoSql.selectAllFull(partner.id)
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE v.partner_id=? $orderBy")
      }
      it("should build selectAllFull for group id and ids") {
        val q = VenueRepoSql.selectAllFull(group.id, NonEmptyList.of(venue.id))
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE pa.group_id=? AND v.id IN (?)  $orderBy")
      }
      it("should build selectAll for contact") {
        val q = VenueRepoSql.selectAll(group.id, contact.id)
        check(q, s"SELECT $fields FROM $table WHERE v.contact_id=? $orderBy")
      }
      it("should build selectPagePublic") {
        val q = VenueRepoSql.selectPagePublic(params)
        check(q, s"SELECT $fieldsPublic FROM $tablePublic GROUP BY pa.slug, pa.name, pa.logo, v.address $orderByPublic LIMIT 20 OFFSET 0")
      }
      it("should build selectOnePublic") {
        val q = VenueRepoSql.selectOnePublic(group.id, venue.id)
        check(q, s"SELECT $fieldsPublic FROM $tablePublic WHERE v.id=? GROUP BY pa.slug, pa.name, pa.logo, v.address $orderByPublic")
      }
      it("should build selectPageCommon") {
        val q = VenueRepoSql.selectPageCommon(params)
        q.fr.query.sql shouldBe s"SELECT $commonFields FROM $commonTable $commonOrderBy LIMIT 20 OFFSET 0"
        // ignored because of fake nullable columns
        // check(q, s"SELECT $commonFields FROM $commonTable $commonOrderBy LIMIT 20 OFFSET 0")
      }
    }
  }
}

object VenueRepoSqlSpec {

  import RepoSpec._

  val table = "venues v"
  val fieldsInsert: String = mapFields("id, partner_id, contact_id, address, address_id, address_lat, address_lng, address_locality, address_country, notes, room_size, meetupGroup, meetupVenue, created_at, created_by, updated_at, updated_by", "v." + _)
  val fields: String = mapFields("id, partner_id, contact_id, address, notes, room_size, meetupGroup, meetupVenue, created_at, created_by, updated_at, updated_by", "v." + _)
  val orderBy = "ORDER BY v.created_at IS NULL, v.created_at"

  private val tableWithPartner = s"$table INNER JOIN $partnerTable ON v.partner_id=pa.id"

  private val tableFull = s"$tableWithPartner LEFT OUTER JOIN $contactTable ON v.contact_id=ct.id"
  private val fieldsFull = s"$fields, $partnerFields, $contactFields"
  private val orderByFull = "ORDER BY v.created_at IS NULL, v.created_at"

  private val tablePublic = s"$tableWithPartner INNER JOIN $groupTable ON pa.group_id=g.id AND g.id != ? INNER JOIN $eventTable ON g.id=e.group_id AND e.venue=v.id AND e.published IS NOT NULL"
  private val fieldsPublic = s"pa.slug, pa.name, pa.logo, v.address, MAX(v.id) as id, COALESCE(COUNT(e.id), 0) as events"
  private val orderByPublic = "ORDER BY pa.name IS NULL, pa.name"

  private val commonTable = s"(" +
    s"(SELECT false as public, pa.slug, pa.name, pa.logo, v.address, v.id, 0 as events FROM $tableWithPartner WHERE pa.group_id=? ORDER BY v.created_at IS NULL, v.created_at) UNION " +
    s"(SELECT true as public, $fieldsPublic FROM $tablePublic GROUP BY public, pa.slug, pa.name, pa.logo, v.address ORDER BY pa.name IS NULL, pa.name)) v"
  private val commonFields = "v.id, v.slug, v.name, v.logo, v.address, v.events, v.public"
  private val commonOrderBy = "ORDER BY v.public IS NULL, v.public, v.name IS NULL, v.name, v.events IS NULL, v.events DESC"
} 

package gospeak.infra.services.storage.sql

import cats.data.NonEmptyList
import gospeak.infra.services.storage.sql.GroupSettingsRepoSqlSpec._
import gospeak.infra.services.storage.sql.testingutils.RepoSpec
import gospeak.infra.services.storage.sql.testingutils.RepoSpec.mapFields

class GroupSettingsRepoSqlSpec extends RepoSpec {
  describe("GroupSettingsRepoSql") {
    describe("Queries") {
      it("should build insert group settings") {
        val q = GroupSettingsRepoSql.insert(group.id, groupSettings, user.id, now)
        check(q, s"INSERT INTO ${table.stripSuffix(" gs")} (${mapFields(fields, _.stripPrefix("gs."))}) VALUES (${mapFields(fields, _ => "?")})")
      }
      it("should build update group settings") {
        val q = GroupSettingsRepoSql.update(group.id, groupSettings, user.id, now)
        check(q, s"UPDATE $table SET ${fields.split(", ").drop(1).map(_.stripPrefix("gs.") + "=?").mkString(", ")} WHERE gs.group_id=?")
      }
      it("should build selectAll group settings") {
        val q = GroupSettingsRepoSql.selectAll(NonEmptyList.of(group.id))(adminCtx)
        check(q, s"SELECT gs.group_id, $fieldsSelect FROM $table WHERE gs.group_id IN (?)  $orderBy")
      }
      it("should build selectOne group settings") {
        val q = GroupSettingsRepoSql.selectOne(group.id)
        check(q, s"SELECT $fieldsSelect FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneAccounts group settings") {
        val q = GroupSettingsRepoSql.selectOneAccounts(group.id)
        check(q, s"SELECT $meetupFields, $slackFields FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneMeetup group settings") {
        val q = GroupSettingsRepoSql.selectOneMeetup(group.id)
        check(q, s"SELECT $meetupFields FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneSlack group settings") {
        val q = GroupSettingsRepoSql.selectOneSlack(group.id)
        check(q, s"SELECT $slackFields FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneEventDescription group settings") {
        val q = GroupSettingsRepoSql.selectOneEventDescription(group.id)
        check(q, s"SELECT gs.event_description FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneEventTemplates group settings") {
        val q = GroupSettingsRepoSql.selectOneEventTemplates(group.id)
        check(q, s"SELECT gs.event_templates FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneProposalTweet group settings") {
        val q = GroupSettingsRepoSql.selectOneProposalTweet(group.id)
        check(q, s"SELECT gs.proposal_tweet FROM $table WHERE gs.group_id=? $orderBy")
      }
      it("should build selectOneActions group settings") {
        val q = GroupSettingsRepoSql.selectOneActions(group.id)
        check(q, s"SELECT gs.actions FROM $table WHERE gs.group_id=? $orderBy")
      }
    }
  }
}

object GroupSettingsRepoSqlSpec {
  val meetupFields: String = mapFields("meetup_access_token, meetup_refresh_token, meetup_group_slug, meetup_logged_user_id, meetup_logged_user_name", "gs." + _)
  val slackFields: String = mapFields("slack_token, slack_bot_name, slack_bot_avatar", "gs." + _)
  val eventFields: String = mapFields("event_description, event_templates", "gs." + _)
  val proposalFields: String = mapFields("proposal_tweet", "gs." + _)

  val table = "group_settings gs"
  val fields = s"gs.group_id, $meetupFields, $slackFields, $eventFields, $proposalFields, gs.actions, gs.updated_at, gs.updated_by"
  val fieldsSelect = s"$meetupFields, $slackFields, $eventFields, $proposalFields, gs.actions"
  val orderBy = "ORDER BY gs.group_id IS NULL, gs.group_id"
} 

package gospeak.infra.services.storage.sql

import cats.data.NonEmptyList
import gospeak.infra.services.storage.sql.ContactRepoSqlSpec.{table => contactTable}
import gospeak.infra.services.storage.sql.PartnerRepoSqlSpec._
import gospeak.infra.services.storage.sql.SponsorRepoSqlSpec.{table => sponsorTable}
import gospeak.infra.services.storage.sql.TablesSpec.socialFields
import gospeak.infra.services.storage.sql.VenueRepoSqlSpec.{table => venueTable}
import gospeak.infra.services.storage.sql.testingutils.RepoSpec
import gospeak.infra.services.storage.sql.testingutils.RepoSpec.mapFields

class PartnerRepoSqlSpec extends RepoSpec {
  describe("PartnerRepoSql") {
    describe("Queries") {
      it("should build insert") {
        val q = PartnerRepoSql.insert(partner)
        check(q, s"INSERT INTO ${table.stripSuffix(" pa")} (${mapFields(fields, _.stripPrefix("pa."))}) VALUES (${mapFields(fields, _ => "?")})")
      }
      it("should build update") {
        val q = PartnerRepoSql.update(group.id, partner.slug)(partner.data, user.id, now)
        check(q, s"UPDATE $table SET slug=?, name=?, notes=?, description=?, logo=?, " +
          s"social_facebook=?, social_instagram=?, social_twitter=?, social_linkedIn=?, social_youtube=?, social_meetup=?, social_eventbrite=?, social_slack=?, social_discord=?, social_github=?, " +
          s"updated_at=?, updated_by=? WHERE pa.group_id=? AND pa.slug=?")
      }
      it("should build delete") {
        val q = PartnerRepoSql.delete(group.id, partner.slug)
        check(q, s"DELETE FROM $table WHERE pa.group_id=? AND pa.slug=?")
      }
      it("should build selectPage") {
        val q = PartnerRepoSql.selectPage(params)
        check(q, s"SELECT $fields FROM $table WHERE pa.group_id=? $orderBy LIMIT 20 OFFSET 0")
      }
      it("should build selectPageFull") {
        val q = PartnerRepoSql.selectPageFull(params)
        check(q, s"SELECT $fieldsFull FROM $tableFull WHERE pa.group_id=? $groupByFull $orderByFull LIMIT 20 OFFSET 0")
      }
      it("should build selectAll") {
        val q = PartnerRepoSql.selectAll(group.id)
        check(q, s"SELECT $fields FROM $table WHERE pa.group_id=? $orderBy")
      }
      it("should build selectAll with partner ids") {
        val q = PartnerRepoSql.selectAll(NonEmptyList.of(partner.id))
        check(q, s"SELECT $fields FROM $table WHERE pa.id IN (?)  $orderBy")
      }
      it("should build selectOne by id") {
        val q = PartnerRepoSql.selectOne(group.id, partner.id)
        check(q, s"SELECT $fields FROM $table WHERE pa.group_id=? AND pa.id=? $orderBy")
      }
      it("should build selectOne by slug") {
        val q = PartnerRepoSql.selectOne(group.id, partner.slug)
        check(q, s"SELECT $fields FROM $table WHERE pa.group_id=? AND pa.slug=? $orderBy")
      }
    }
  }
}

object PartnerRepoSqlSpec {
  val table = "partners pa"
  val fields: String = mapFields(s"id, group_id, slug, name, notes, description, logo, $socialFields, created_at, created_by, updated_at, updated_by", "pa." + _)
  val orderBy = "ORDER BY pa.name IS NULL, pa.name"

  private val tableFull = s"$table LEFT OUTER JOIN $venueTable ON pa.id=v.partner_id LEFT OUTER JOIN $sponsorTable ON pa.id=s.partner_id LEFT OUTER JOIN $contactTable ON pa.id=ct.partner_id LEFT OUTER JOIN events e ON v.id=e.venue"
  private val fieldsFull = s"$fields, COALESCE(COUNT(DISTINCT v.id), 0) as venueCount, COALESCE(COUNT(DISTINCT s.id), 0) as sponsorCount, MAX(s.finish) as lastSponsorDate, COALESCE(COUNT(DISTINCT ct.id), 0) as contactCount, COALESCE(COUNT(DISTINCT e.id), 0) as eventCount, MAX(e.start) as lastEventDate"
  private val groupByFull = s"GROUP BY $fields"
  private val orderByFull = "ORDER BY LOWER(pa.name) IS NULL, LOWER(pa.name)"
} 

package gospeak.infra.services.storage.sql

import cats.data.NonEmptyList
import gospeak.infra.services.storage.sql.SponsorPackRepoSqlSpec._
import gospeak.infra.services.storage.sql.testingutils.RepoSpec
import gospeak.infra.services.storage.sql.testingutils.RepoSpec.mapFields

class SponsorPackRepoSqlSpec extends RepoSpec {
  describe("SponsorPackRepoSql") {
    describe("Queries") {
      it("should build insert") {
        val q = SponsorPackRepoSql.insert(sponsorPack)
        check(q, s"INSERT INTO ${table.stripSuffix(" sp")} (${mapFields(fields, _.stripPrefix("sp."))}) VALUES (${mapFields(fields, _ => "?")})")
      }
      it("should build update") {
        val q = SponsorPackRepoSql.update(group.id, sponsorPack.slug)(sponsorPack.data, user.id, now)
        check(q, s"UPDATE $table SET slug=?, name=?, description=?, price=?, currency=?, duration=?, updated_at=?, updated_by=? WHERE sp.group_id=? AND sp.slug=?")
      }
      it("should build setActive") {
        val q = SponsorPackRepoSql.setActive(group.id, sponsorPack.slug)(active = true, user.id, now)
        check(q, s"UPDATE $table SET active=?, updated_at=?, updated_by=? WHERE sp.group_id=? AND sp.slug=?")
      }
      it("should build selectOne") {
        val q = SponsorPackRepoSql.selectOne(group.id, sponsorPack.slug)
        check(q, s"SELECT $fields FROM $table WHERE sp.group_id=? AND sp.slug=? $orderBy")
      }
      it("should build selectAll ids") {
        val q = SponsorPackRepoSql.selectAll(NonEmptyList.of(sponsorPack.id, sponsorPack.id))
        check(q, s"SELECT $fields FROM $table WHERE sp.id IN (?, ?)  $orderBy")
      }
      it("should build selectAll") {
        val q = SponsorPackRepoSql.selectAll(group.id)
        check(q, s"SELECT $fields FROM $table WHERE sp.group_id=? $orderBy")
      }
      it("should build selectActives") {
        val q = SponsorPackRepoSql.selectActives(group.id)
        check(q, s"SELECT $fields FROM $table WHERE sp.group_id=? AND sp.active=? $orderBy")
      }
    }
  }
}

object SponsorPackRepoSqlSpec {
  val table = "sponsor_packs sp"
  val fields: String = mapFields("id, group_id, slug, name, description, price, currency, duration, active, created_at, created_by, updated_at, updated_by", "sp." + _)
  val orderBy = "ORDER BY sp.active IS NULL, sp.active DESC, sp.price IS NULL, sp.price DESC"
} 

package gospeak.libs.openapi.models

import cats.data.NonEmptyList
import gospeak.libs.scala.Extensions._
import gospeak.libs.openapi.error.OpenApiError

final case class Schemas(value: Map[String, Schema]) extends AnyVal {
  def get(name: String): Option[Schema] = value.get(name)

  def resolve(schema: Schema): Either[NonEmptyList[OpenApiError], Option[Schema]] = schema match {
    case s: Schema.StringVal => Right(Some(s))
    case s: Schema.IntegerVal => Right(Some(s))
    case s: Schema.NumberVal => Right(Some(s))
    case s: Schema.BooleanVal => Right(Some(s))
    case s: Schema.ArrayVal => resolve(s.items).map(_.map(r => s.copy(items = r))).left.map(_.map(_.atPath(s".items")))
    case s: Schema.ObjectVal =>
      s.properties.map { case (name, value) =>
        resolve(value).map(res => (name, res)).left.map(_.map(_.atPath(".properties", s".$name")))
      }.sequence.map(p => p.map { case (k, v) => v.map(k -> _) }.sequence).map(_.map(p => s.copy(properties = p.toMap)))
    case s: Schema.ReferenceVal => s.$ref.localRef match {
      case Some(("schemas", name)) => get(name).toRight(NonEmptyList.of(OpenApiError.missingReference(s.$ref.value).atPath(".$ref"))).flatMap(resolve)
      case Some((component, _)) => Left(NonEmptyList.of(OpenApiError.badReference(s.$ref.value, component, "schemas")))
      case None => Right(None)
    }
    case s: Schema.CombinationVal => s.oneOf.map(_.zipWithIndex.map { case (s, i) =>
      resolve(s).left.map(_.map(_.atPath(".oneOf", s"[$i]")))
    }.sequence).sequence.map(_.flatMap(_.sequence.map(a => Schema.CombinationVal(Some(a)))))
  }

  def contains(name: String): Boolean = value.contains(name)
}

object Schemas {
  def apply(values: (String, Schema)*): Schemas = new Schemas(values.toMap)
} 

package gospeak.libs.openapi.models

import cats.data.NonEmptyList
import gospeak.libs.openapi.OpenApiUtils
import gospeak.libs.openapi.error.OpenApiError
import gospeak.libs.openapi.models.utils.{TODO, Version}
import gospeak.libs.scala.Extensions._


final case class OpenApi(openapi: Version,
                         info: Info,
                         externalDocs: Option[ExternalDoc],
                         servers: Option[List[Server]],
                         tags: Option[List[Tag]],
                         security: Option[TODO],
                         components: Option[Components],
                         paths: Map[Path, PathItem],
                         extensions: Option[TODO]) {
  def getSchemas: Schemas = components.flatMap(_.schemas).getOrElse(Schemas())

  def getErrors: List[OpenApiError] = {
    val s = getSchemas
    OpenApi.groupErrors(
      OpenApiUtils.validate("servers", servers.getOrElse(List()), s) ++
        components.map(_.getErrors(s)).getOrElse(List()).map(_.atPath(".components")) ++
        OpenApiUtils.validate("paths", paths.map { case (k, v) => (k.value, v) }, s) ++
        OpenApiUtils.noDuplicates[Tag]("tags", tags.getOrElse(List()), _.name) ++
        OpenApi.checkDuplicatedPaths(paths).map(_.atPath(".paths")) ++
        OpenApi.checkDuplicatedOperationIds(paths).map(_.atPath(".paths"))
    )
  }
}

object OpenApi {
  def checkDuplicatedPaths(paths: Map[Path, PathItem]): List[OpenApiError] =
    paths.keys
      .groupBy(_.mapVariables(_ => "?").value)
      .filter(_._2.size > 1)
      .values.flatMap(_.lastOption).toList
      .map(path => OpenApiError.duplicateValue(path.value).atPath(s".${path.value}"))

  def checkDuplicatedOperationIds(paths: Map[Path, PathItem]): List[OpenApiError] =
    paths.flatMap { case (path, item) =>
      item.operations.flatMap { case (key, op) =>
        op.operationId.map(id => (List(s".${path.value}", s".$key"), id))
      }
    }.toList.groupBy(_._2)
      .filter(_._2.size > 1)
      .values.flatMap(_.lastOption).toList
      .map { case (path, opId) => OpenApiError.duplicateValue(opId).atPath(path) }

  def groupErrors(errors: List[OpenApiError]): List[OpenApiError] =
    errors.groupBy(_.path).flatMap { case (path, errors) =>
      errors.toNel.map(errs => OpenApiError(path, errs.flatMap(_.errors))).toOption
    }.toList.sortBy(_.path.mkString)
} 

package com.wavesplatform.dex.model

import cats.data.NonEmptyList
import com.wavesplatform.dex.settings.DenormalizedMatchingRule
import com.wavesplatform.dex.{MatcherSpecBase, NoShrink}
import org.scalacheck.Gen
import org.scalatest.matchers.should.Matchers
import org.scalatest.propspec.AnyPropSpec
import org.scalatestplus.scalacheck.{ScalaCheckPropertyChecks => PropertyChecks}

class DenormalizedMatchingRulesSpecification extends AnyPropSpec with PropertyChecks with Matchers with MatcherSpecBase with NoShrink {
  property("skipOutdated: rules.head.startOffset <= currentOffset < rules(1).startOffset") {
    val g = for {
      currOffset <- currOffsetGen
      rules      <- rulesChainGen(5)
    } yield (currOffset, rules)

    forAll(g) {
      case (currOffset, rules) =>
        val updatedRules = DenormalizedMatchingRule.skipOutdated(currOffset, rules)
        updatedRules.toList match {
          case first :: Nil =>
            withClue(s"first.startOffset=${first.startOffset}, currOffset=$currOffset") {
              first.startOffset shouldBe <=(currOffset)
            }
          case first :: second :: _ =>
            withClue(s"first.startOffset=${first.startOffset}, currOffset=$currOffset") {
              first.startOffset shouldBe <=(currOffset)
            }
            withClue(s"currOffset=$currOffset, second.startOffset=${second.startOffset}") {
              currOffset shouldBe <(second.startOffset)
            }
          case xs => throw new IllegalStateException(s"$xs")
        }
    }
  }

  private val currOffsetGen = Gen.choose(0L, Long.MaxValue)

  private def nextRulesGen(prevRules: DenormalizedMatchingRule): Gen[Option[DenormalizedMatchingRule]] =
    if (prevRules.startOffset == Long.MaxValue) Gen.const(None)
    else
      for {
        startOffset <- Gen.choose(prevRules.startOffset + 1, Long.MaxValue)
        tickSize    <- Gen.choose(1, Double.MaxValue)
      } yield Some(DenormalizedMatchingRule(startOffset, tickSize))

  private val firstRuleGen: Gen[DenormalizedMatchingRule] = Gen.choose(1, Double.MaxValue).map(DenormalizedMatchingRule(0L, _))

  private def rulesChainGen(maxNumber: Int): Gen[NonEmptyList[DenormalizedMatchingRule]] = {
    def loop(rest: Int, acc: Gen[NonEmptyList[DenormalizedMatchingRule]]): Gen[NonEmptyList[DenormalizedMatchingRule]] =
      if (rest == 0) acc
      else
        for {
          xs <- acc
          x  <- nextRulesGen(xs.head)
          r  <- x.fold(Gen.const(xs))(x => loop(rest - 1, Gen.const(x :: xs)))
        } yield r

    Gen.lzy(loop(maxNumber, firstRuleGen.map(NonEmptyList.one)).map(_.reverse))
  }
}