lihaoyi/upickle

import upickle.default.{ ReadWriter => RW, macroRW }

object BrandEntity {

  final case class Brand(id: Option[BrandID], value: BrandValueObject)

  final case class BrandID private (url: String)
  final case class BrandValueObject private (name: Option[BrandName], country: Option[Country])

  final case class BrandName private (name: String)
  final case class Country private (country: String)

  case class RawBrand(pageUrl: String, brandName: String, country: String)

  // https://stackoverflow.com/questions/27941585/pattern-matching-to-check-if-string-is-null-or-empty
  // vs
  // https://youtu.be/BIt3jLLGY0s?t=729 (https://github.com/lutzh/pattern-matching-talk/blob/master/pattern-matching.txt)
  // vs
  // https://riptutorial.com/scala/example/3434/unapply---custom-extractors

  object Brand {
    implicit val rw: RW[Brand] = macroRW
    def apply(rawBrand: RawBrand): Brand = {
      Brand(BrandID(rawBrand.pageUrl), BrandValueObject(rawBrand.brandName, rawBrand.country))
    }
  }

  object BrandID {
    implicit val rw: RW[BrandID] = macroRW
    // hide default ctor
    private[this] def apply() = None

    private[this] def unapply(url: String): Option[String] = if (url == null || url.trim.isEmpty) None else Some(url)

    def apply(url: String): Option[BrandID] = {
      url match {
        case BrandID(url) => Some(new BrandID(url))
        case _ => None
      }
    }
  }

  object BrandValueObject {
    implicit val rw: RW[BrandValueObject] = macroRW
    // hide default ctor
    private[this] def apply() = new BrandValueObject(None, None)

    private[BrandEntity] def isEmpty(value: String) = (value == null || value.trim.isEmpty)

    def apply(name: String, country: String) = {
      (name, country) match {
        case (name, country) if (isEmpty(name) && isEmpty(country)) => new BrandValueObject(None, None)
        case (name, country) if (isEmpty(name)) => new BrandValueObject(None, Some(Country(country)))
        case (name, country) if (isEmpty(country)) => new BrandValueObject(Some(BrandName(name)), None)
        case _ => new BrandValueObject(Some(BrandName(name)), Some(Country(country)))
      }
    }
  }

  object BrandName {
    implicit val rw: RW[BrandName] = macroRW
    // hide default ctor
    private[BrandEntity] def apply() = new BrandName("")
    private[BrandEntity] def apply(name: String) = new BrandName("")
  }

  object Country {
    implicit val rw: RW[Country] = macroRW
    // hide default ctor
    private[BrandEntity] def apply() = new Country("")
    private[BrandEntity] def apply(name: String) = new Country("")
  }
}

[error] ...../01-entities/src/main/scala/de/mobe/scraper/entities/Brand.scala:31:36: type mismatch;
[error]  found   : Option[de.mobe.scraper.entities.BrandEntity.BrandID]
[error]  required: de.mobe.scraper.entities.BrandEntity.BrandID
[error]     implicit val rw: RW[BrandID] = macroRW