brianhsu

abstract class UseCaseExecutor {
  
  def execute[T](useCase: UseCase[T]): Try[T] = {

    Try {
      useCase.validate().foreach { error => throw error }
      val result = useCase.execute()
      useCase.journal.foreach(appendJournal)
      result
    }

brianhsu

object UseCaseExecutor {
  type Presenter[T, R] = (Try[T] => R)
}

abstract class UseCaseExecutor {

  import UseCaseExecutor.Presenter

  def execute[T, R](useCase: UseCase[T])(presenter: Presenter[T, R]): R = {

brianhsu

object InMemoryUser {

  def makeInMemoryUser: UserRepo = {
    val inMemory = new InMemoryUserReadable with InMemoryUserWritable
    UserRepo(inMemory, inMemory)
  }

  trait InMemoryUserBase {
    protected var userList: List[User] = Nil
  }

brianhsu

case class UserRepo(read: UserReadable, write: UserWritable)

trait UserReadable {
  def find(email: String): Option[User]
}

trait UserWritable {
  def insert(user: User): Unit
}

brianhsu

trait DynamicDataGenerator {
  def randomUUID: UUIDGenerator
  def currentTime: CurrentTimeGenerator
}

trait UUIDGenerator {
  def uuid: UUID
}

trait CurrentTimeGenerator {

brianhsu

object CreateUser {
  case class Request(email: String, name: String)
}

class CreateUser(request: CreateUser.Request)
                (implicit val userRepo: UserRepo, implicit val generator: DynamicDataGenerator) extends UseCase[User] {

  private lazy val uuid = generator.randomUUID.uuid
  private lazy val nowTime = generator.currentTime.time
  private lazy val user = User(uuid, request.email, request.name, nowTime, nowTime)

brianhsu

trait UseCase[T] {
  def execute(): T
  def validate(): Option[ValidationError]
  def journal: Option[Journal]
}

brianhsu

trait Entity

case class Stuff(
  uuid: UUID, userUUID: UUID, 
  title: String, description: String, 
  createTime: LocalDateTime, updateTime: LocalDateTime, 
  isTrash: Boolean = false) extends Entity

case class User(
  uuid: UUID, email: String, name: String, 

brianhsu

class CreateUserSpec extends fixture.WordSpec with Matchers with OptionValues {

  "CreateUser" when {

    "validate request" should {
      "return an exception if email is empty" in { fixture =>
        pending
      }

      "return an exception if email is effectively empty" in { fixture =>

brianhsu

package moe.brianhsu.gtd.usecase

import moe.brianhsu.gtd.journal.Journal

import scala.util._

object UseCaseExecutor {
  type Presenter[T, R] = (Try[T] => R)
}