scalacheck generators

import org.joda.time.DateTime

import org.scalacheck.{Arbitrary, Gen}
import org.scalacheck.Gen.oneOf

import scalaz._
import Scalaz._

trait ProjectDateGenerator {
  case class Year(q: String, a: Option[Int])
  case class Month(q: String, a: Option[Int])
  case class Date(q: String, year: Year, month: Month)

  val dateGen: Gen[Date] = for {
    year  <- oneOf(emptyYearGen, yearGen)
    month <- oneOf(emptyMonthGen, alphaMonthGen, numericMonthGen)
    input <- inputGen(year, month)
  } yield Date(input, year, month)

  implicit val arbContexts = Arbitrary(dateGen)

  // privates

  private lazy val emptyYearGen: Gen[Year] = oneOfSeq(Year("", None))
  private lazy val yearGen: Gen[Year] = oneOf((1950 to DateTime.now.getYear) map (y => Year(y.toString, Some(y))))

  private lazy val emptyMonthGen: Gen[Month] = oneOfSeq(Month("", None))
  private lazy val alphaMonthGen: Gen[Month] = {
    val variants = for {
      (m, spellings) <- ResourceLoader.months()
      spelling       <- spellings
    } yield Month(spelling, Some(m))
    oneOf(variants.toSeq)
  }
  private lazy val numericMonthGen: Gen[Month] = {
    val variants = for {
      m     <- 1 to 12
      month <- Seq(Month(m.toString, Some(m)), Month(padZeros(m, 2), Some(m))) // gen both "1" and "01"
    } yield month
    oneOf(variants)
  }

  private def inputGen(year: Year, month: Month): Gen[String] = {
    val inputs = {
      def join(s1: String, w: String, s2: String): String =
        if (s1.isEmpty) s2
        else if (s2.isEmpty) s1
        else s1 + w + s2

      import scala.language.implicitConversions
      implicit def yearToString(y: Year): String = if (y.a.isDefined) y.q else ""
      implicit def monthToString(m: Month): String = if (m.a.isDefined) m.q else ""

      List(
        join(month, " ", year),  // september 2010, sep 2010, 09 2010
        join(year,  " ", month), // 2010 september, 2010 sep, 2010 09
        join(month, ".", year),  // september.2010, sep.2010, 09.2010
        join(year,  ".", month), // 2010.september, 2010.sep, 2010.09
        join(year,  "",  month), // 2010september,  2010sep,  201009
        join(month, "",  year)   // september2010,  sep2010,  092010
      )
    }

    def addNoise(inputs: List[String]): List[String] =
      inputs <*> List(identity, "from " + _, "since " + _, "to " + _, "till " + _)

    oneOfSeq(addNoise(inputs): _*)
  }

  private def oneOfSeq[T](xs: T*) = oneOf(xs)
  private def padZeros(i: Int, width: Int): String = { val spec = s"%0${width}d"; spec.format(i) }
}

----------------------------------------------------------------------------------------------

import org.scalatest.FunSuite
import org.scalatest.prop.Checkers
import org.scalacheck.Prop.forAll

class ProjectDateParserSpec extends FunSuite
with Checkers
with Generators
with ParseFunctions {

  test("project dates parser") { check(forAll { satisfies _ }) }

  private def satisfies(date: Date) = {
    val result = parseDate(date.q)
    val year = result.year
    val month = result.month

    year == date.year.a && month == date.month.a
  }
}