daveD - simplify erase generators

src/main/scala/io/github/databob/Generator.scala

@@ -1,6 +1,6 @@
 package io.github.databob
 
-import io.github.databob.generators.{Generators, TypeGenerator}
+import io.github.databob.generators.{ErasureBasedGenerator, Generators, TypeGenerator}
 
 trait Generator[A] {
   def mk(databob: Databob): PartialFunction[GeneratorType, A]
@@ -9,5 +9,12 @@ trait Generator[A] {
 
 object Generator {
   def apply[A: Manifest](mk: Databob => A): Generator[A] = new TypeGenerator[A](mk)
-  def typeBased[A: Manifest](mk: Databob => A): Generator[A] = new TypeGenerator[A](mk)
+  def typeIs[A: Manifest](mk: Databob => A): Generator[A] = new TypeGenerator[A](mk)
+
+  def erasureIsAssignableFrom[R: Manifest](fn: (GeneratorType, Databob) => R) =
+    new ErasureBasedGenerator(_.isAssignableFrom(implicitly[Manifest[R]].runtimeClass), fn)
+
+  def erasureIs[R: Manifest](fn: Databob => R) =
+    new ErasureBasedGenerator(_ == implicitly[Manifest[R]].runtimeClass, (gt, databob) => fn(databob))
+
 }

src/main/scala/io/github/databob/generators/CollectionGenerators.scala

@@ -1,16 +1,16 @@
 package io.github.databob.generators
 
-import io.github.databob.generators.ErasureBasedGenerator.erasureIsAssignableFrom
+import io.github.databob.Generator.erasureIsAssignableFrom
 
 object CollectionGenerators {
   val Empty = new Generators(
     List(
       new ErasureBasedGenerator[java.util.ArrayList[_]](_.isArray, (gt, databob) => new java.util.ArrayList[Any]()),
-      erasureIsAssignableFrom[java.util.ArrayList[_]](databob => new java.util.ArrayList[Any]()),
-      erasureIsAssignableFrom[Map[_, _]](databob => Map()),
-      erasureIsAssignableFrom[Set[_]](databob => Set()),
-      erasureIsAssignableFrom[List[_]](databob => List()),
-      erasureIsAssignableFrom[Seq[_]](databob => Seq())
+      erasureIsAssignableFrom[java.util.ArrayList[_]]((gt, databob) => new java.util.ArrayList[Any]()),
+      erasureIsAssignableFrom[Map[_, _]]((gt, databob) => Map()),
+      erasureIsAssignableFrom[Set[_]]((gt, databob) => Set()),
+      erasureIsAssignableFrom[List[_]]((gt, databob) => List()),
+      erasureIsAssignableFrom[Seq[_]]((gt, databob) => Seq())
     )
   )
 

src/main/scala/io/github/databob/generators/ErasureBasedGenerator.scala

@@ -7,17 +7,3 @@ class ErasureBasedGenerator[A: Manifest](predicate: (Class[_]) => Boolean, fn: (
     case generatorType if predicate(generatorType.erasure) => fn(generatorType, databob)
   }
 }
-
-object ErasureBasedGenerator {
-  def erasureIsAssignableFrom2[R: Manifest](fn: (GeneratorType, Databob) => R) =
-    new ErasureBasedGenerator(_.isAssignableFrom(implicitly[Manifest[R]].runtimeClass), fn)
-
-  def erasureIsAssignableFrom[R: Manifest](fn: Databob => R) =
-    new ErasureBasedGenerator(_.isAssignableFrom(implicitly[Manifest[R]].runtimeClass), (gt, databob) => fn(databob))
-
-  def erasureIs2[R: Manifest](fn: (GeneratorType, Databob) => R) =
-    new ErasureBasedGenerator(_ == implicitly[Manifest[R]].runtimeClass, fn)
-
-  def erasureIs[R: Manifest](fn: Databob => R) =
-    new ErasureBasedGenerator(_ == implicitly[Manifest[R]].runtimeClass, (gt, databob) => fn(databob))
-}

src/main/scala/io/github/databob/generators/JavaDateTimeGenerators.scala

@@ -5,20 +5,19 @@ import java.time._
 import java.util.Date
 
 import io.github.databob.Generator._
-import io.github.databob.generators.ErasureBasedGenerator._
 
 object JavaDateTimeGenerators {
   val Default = new Generators(
     List(
-      typeBased(databob => Instant.ofEpochMilli(0)),
-      typeBased(databob => LocalDate.from(databob.mk[ZonedDateTime])),
-      typeBased(databob => LocalTime.from(databob.mk[ZonedDateTime])),
-      typeBased(databob => LocalDateTime.from(databob.mk[ZonedDateTime])),
-      typeBased(databob => ZonedDateTime.ofInstant(databob.mk[Instant], ZoneId.systemDefault())),
+      typeIs(databob => Instant.ofEpochMilli(0)),
+      typeIs(databob => LocalDate.from(databob.mk[ZonedDateTime])),
+      typeIs(databob => LocalTime.from(databob.mk[ZonedDateTime])),
+      typeIs(databob => LocalDateTime.from(databob.mk[ZonedDateTime])),
+      typeIs(databob => ZonedDateTime.ofInstant(databob.mk[Instant], ZoneId.systemDefault())),
       erasureIs(databob => new Date(databob.mk[Instant].toEpochMilli)),
       erasureIs(databob => new Timestamp(databob.mk[Instant].toEpochMilli))
     )
   )
 
-  val Random = typeBased(databob => Instant.ofEpochMilli(0)) +: Default
+  val Random = typeIs(databob => Instant.ofEpochMilli(0)) +: Default
 }

src/main/scala/io/github/databob/generators/JavaPrimitiveGenerators.scala

@@ -3,7 +3,7 @@ package io.github.databob.generators
 import java.lang.{Boolean => JavaBoolean, Byte => JavaByte, Double => JavaDouble, Float => JavaFloat, Integer => JavaInteger, Long => JavaLong, Short => JavaShort, String => JavaString}
 import java.math.{BigDecimal => JavaBigDecimal, BigInteger => JavaBigInteger}
 
-import io.github.databob.generators.ErasureBasedGenerator._
+import io.github.databob.Generator.erasureIs
 
 object JavaPrimitiveGenerators {
   val Defaults = new Generators(

src/main/scala/io/github/databob/generators/MonadGenerators.scala

@@ -1,6 +1,6 @@
 package io.github.databob.generators
 
-import io.github.databob.generators.ErasureBasedGenerator._
+import io.github.databob.Generator._
 
 import scala.concurrent.Future
 import scala.util.{Failure, Success, Try}
@@ -9,19 +9,19 @@ object MonadGenerators {
 
   val Happy = new Generators(
     List(
-      erasureIsAssignableFrom2[Try[_]]((gt, databob) => Success(databob.mk(gt.typeArgs.head))),
-      erasureIsAssignableFrom2[Future[_]]((gt, databob) => Future.successful(databob.mk(gt.typeArgs.head))),
-      erasureIsAssignableFrom2[Option[_]]((gt, databob) => Option(databob.mk(gt.typeArgs.head))),
-      erasureIsAssignableFrom2[Either[_, _]]((gt, databob) => Right(databob.mk(gt.typeArgs(1))))
+      erasureIsAssignableFrom[Try[_]]((gt, databob) => Success(databob.mk(gt.typeArgs.head))),
+      erasureIsAssignableFrom[Future[_]]((gt, databob) => Future.successful(databob.mk(gt.typeArgs.head))),
+      erasureIsAssignableFrom[Option[_]]((gt, databob) => Option(databob.mk(gt.typeArgs.head))),
+      erasureIsAssignableFrom[Either[_, _]]((gt, databob) => Right(databob.mk(gt.typeArgs(1))))
     )
   )
 
   val Unhappy = new Generators(
     List(
-      erasureIsAssignableFrom[Try[_]](databob => Failure(databob.mk[Exception])),
-      erasureIsAssignableFrom[Future[_]](databob => Future.failed(databob.mk[Exception])),
-      erasureIsAssignableFrom[Option[_]](databob => None),
-      erasureIsAssignableFrom2[Either[_, _]]((gt, databob) => Left(databob.mk(gt.typeArgs.head)))
+      erasureIsAssignableFrom[Try[_]]((gt, databob) => Failure(databob.mk[Exception])),
+      erasureIsAssignableFrom[Future[_]]((gt, databob) => Future.failed(databob.mk[Exception])),
+      erasureIsAssignableFrom[Option[_]]((gt, databob) => None),
+      erasureIsAssignableFrom[Either[_, _]]((gt, databob) => Left(databob.mk(gt.typeArgs.head)))
     )
   )
 

src/main/scala/io/github/databob/generators/ScalaPrimitiveGenerators.scala

@@ -1,6 +1,6 @@
 package io.github.databob.generators
 
-import io.github.databob.generators.ErasureBasedGenerator.erasureIs
+import io.github.databob.Generator._
 
 object ScalaPrimitiveGenerators {
   val Defaults = new Generators(