Merge branch 'release/0.7.1'

Author: ianoc

CHANGES.md

@@ -1,5 +1,12 @@
 # Bijection #
 
+### 0.7.1
+* Remove some package privacy so these things can be used in scalding and ...: https://github.com/twitter/bijection/pull/190
+* Add macros to create Trys: https://github.com/twitter/bijection/pull/187
+* Refactor macros: https://github.com/twitter/bijection/pull/186
+* Add TypeclassBijection: https://github.com/twitter/bijection/pull/183
+* Generate some useful case class conversions with macros: https://github.com/twitter/bijection/pull/179
+
 ### 0.7.0
 * Added thrift json injections: https://github.com/twitter/bijection/pull/172
 * Make almost all the case classes extend AnyVal: https://github.com/twitter/bijection/pull/178

README.md

@@ -132,7 +132,7 @@ Discussion occurs primarily on the [Bijection mailing list](https://groups.googl
 
 ## Maven
 
-Bijection modules are available on maven central. The current groupid and version for all modules is, respectively, `"com.twitter"` and  `0.7.0`.
+Bijection modules are available on maven central. The current groupid and version for all modules is, respectively, `"com.twitter"` and  `0.7.1`.
 
 Current published artifacts are
 

bijection-core/src/main/scala/com/twitter/bijection/TypeclassBijection.scala

@@ -0,0 +1,20 @@
+package com.twitter.bijection
+
+object TypeclassBijection {
+  implicit class RichTypeclass[T[_], A](t: T[A]) {
+    def bijectTo[B](implicit tcBij: TypeclassBijection[T], bij: ImplicitBijection[A, B]): T[B] = tcBij(t, bij.bijection)
+  }
+
+  object BijectionAndTypeclass {
+    implicit def get[T[_], From, To](implicit bij: ImplicitBijection[To, From], typeclass: T[From]) = BijectionAndTypeclass(bij, typeclass)
+  }
+  case class BijectionAndTypeclass[T[_], From, To](bij: ImplicitBijection[To, From], typeclass: T[From]) {
+    def apply(tc: TypeclassBijection[T]): T[To] = TypeclassBijection.typeclassBijection[T, From, To](tc, typeclass, ImplicitBijection.reverse(bij.bijection))
+  }
+
+  def typeclassBijection[T[_], A, B](implicit tcBij: TypeclassBijection[T], typeclass: T[A], bij: ImplicitBijection[A, B]): T[B] = tcBij(typeclass, bij.bijection)
+  def deriveFor[T[_], To](implicit tcBij: TypeclassBijection[T], batc: BijectionAndTypeclass[T, From, To] forSome { type From }): T[To] = batc(tcBij)
+}
+trait TypeclassBijection[T[_]] {
+  def apply[A, B](tc: T[A], bij: Bijection[A, B]): T[B]
+}

bijection-core/src/test/scala/com/twitter/bijection/TypeclassBijectionLaws.scala

@@ -0,0 +1,76 @@
+package com.twitter.bijection
+
+import org.scalatest.{ PropSpec, MustMatchers }
+import org.scalatest.prop.PropertyChecks
+
+class TypeclassBijectionLaws extends PropSpec with PropertyChecks with MustMatchers with BaseProperties {
+  import FakeAlgebird._
+  import TypeclassBijection._
+
+  case class A(x: Int, y: String)
+  implicit val abij: Bijection[A, (Int, String)] = Bijection.build[A, (Int, String)] { A.unapply(_).get } { x => A(x._1, x._2) }
+
+  implicit val orderingTypeclassBijection: TypeclassBijection[Ordering] = new TypeclassBijection[Ordering] {
+    def apply[A, B](tc: Ordering[A], bij: Bijection[A, B]) = tc.on { bij.invert(_) }
+  }
+
+  implicit val numericTypeclassBijection: TypeclassBijection[Numeric] = new TypeclassBijection[Numeric] {
+    def apply[A, B](tc: Numeric[A], bij: Bijection[A, B]) =
+      new Numeric[B] {
+        def plus(x: B, y: B) = bij(tc.plus(bij.invert(x), bij.invert(y)))
+        def minus(x: B, y: B) = bij(tc.minus(bij.invert(x), bij.invert(y)))
+        def times(x: B, y: B) = bij(tc.times(bij.invert(x), bij.invert(y)))
+        def negate(x: B) = bij(tc.negate(bij.invert(x)))
+        def fromInt(x: Int) = bij(tc.fromInt(x))
+        def toInt(x: B) = tc.toInt(bij.invert(x))
+        def toLong(x: B) = tc.toLong(bij.invert(x))
+        def toFloat(x: B) = tc.toFloat(bij.invert(x))
+        def toDouble(x: B) = tc.toDouble(bij.invert(x))
+        def compare(x: B, y: B) = tc.compare(bij.invert(x), bij.invert(y))
+      }
+  }
+
+  case class Wrapper(get: Int)
+  implicit val wrapperbij: Bijection[Wrapper, Int] = Bijection.build[Wrapper, Int] { _.get } { Wrapper(_) }
+
+  property("basic") {
+    implicitly[Semigroup[Int]]
+    implicitly[Semigroup[String]]
+    implicitly[Semigroup[(Int, String)]]
+    typeclassBijection[Semigroup, (Int, String), A]
+    implicitly[Semigroup[(Int, String)]].bijectTo[A]
+    deriveFor[Semigroup, A]
+    deriveFor[Ordering, A]
+    deriveFor[Ordering, Wrapper]
+    deriveFor[Numeric, Wrapper]
+  }
+}
+
+object FakeAlgebird {
+  object Semigroup {
+    implicit val intSemigroup: Semigroup[Int] =
+      new Semigroup[Int] {
+        override def plus(left: Int, right: Int) = left + right
+      }
+
+    implicit val strSemigroup: Semigroup[String] =
+      new Semigroup[String] {
+        override def plus(left: String, right: String) = left + right
+      }
+
+    implicit def tup2Semigroup[A, B](implicit s1: Semigroup[A], s2: Semigroup[B]): Semigroup[(A, B)] =
+      new Semigroup[(A, B)] {
+        override def plus(l: (A, B), r: (A, B)) = (s1.plus(l._1, r._1), s2.plus(l._2, r._2))
+      }
+
+    implicit val semigroupTypeclassBijection: TypeclassBijection[Semigroup] = new TypeclassBijection[Semigroup] {
+      def apply[A, B](tc: Semigroup[A], bij: Bijection[A, B]) =
+        new Semigroup[B] {
+          override def plus(left: B, right: B) = bij(tc.plus(bij.invert(left), bij.invert(right)))
+        }
+    }
+  }
+  trait Semigroup[T] {
+    def plus(left: T, right: T): T
+  }
+}

bijection-macros/src/main/scala/com/twitter/bijection/macros/MacroAnnotations.scala

@@ -0,0 +1,18 @@
+package com.twitter.bijection.macros
+
+import scala.language.experimental.macros
+import com.twitter.bijection.macros.impl._
+
+/**
+ * This trait is meant to be used exclusively to allow the type system to prove that a class is or is not a case class.
+ */
+object IsCaseClass {
+  implicit def isCaseClass[T]: IsCaseClass[T] = macro IsCaseClassImpl.isCaseClassImpl[T]
+}
+
+trait IsCaseClass[T]
+
+/**
+ * This is a tag trait to allow macros to signal, in a uniform way, that a piece of code was generated.
+ */
+trait MacroGenerated

bijection-macros/src/main/scala/com/twitter/bijection/macros/MacroImplicits.scala

@@ -0,0 +1,21 @@
+package com.twitter.bijection.macros
+
+import scala.language.experimental.macros
+
+import com.twitter.bijection._
+import com.twitter.bijection.macros.impl.{ CaseClassToTuple, CaseClassToMap, IsCaseClassImpl }
+
+trait LowerPriorityMacroImplicits {
+  // Since implicit macro's aborting makes them just appear to never having existed
+  // its valid for this to be lower priority for the one in MacroImplicits.
+  // We will attempt this one if we don't see the other
+  implicit def materializeCaseClassToTupleNonRecursive[T: IsCaseClass, Tup]: Bijection[T, Tup] = macro CaseClassToTuple.caseClassToTupleImplNonRecursive[T, Tup]
+}
+
+object MacroImplicits extends LowerPriorityMacroImplicits {
+
+  implicit def materializeCaseClassToTuple[T: IsCaseClass, Tup]: Bijection[T, Tup] = macro CaseClassToTuple.caseClassToTupleImpl[T, Tup]
+  implicit def materializeCaseClassToMap[T: IsCaseClass]: Injection[T, Map[String, Any]] = macro CaseClassToMap.caseClassToMapImpl[T]
+
+  implicit def isCaseClass[T]: IsCaseClass[T] = macro IsCaseClassImpl.isCaseClassImpl[T]
+}

bijection-macros/src/main/scala/com/twitter/bijection/macros/Macros.scala

@@ -0,0 +1,28 @@
+package com.twitter.bijection.macros
+
+import scala.language.experimental.macros
+
+import com.twitter.bijection._
+import com.twitter.bijection.macros.impl.{ CaseClassToTuple, CaseClassToMap, TryMacros }
+
+import scala.util.Try
+
+object Macros {
+  def caseClassToTuple[T: IsCaseClass, Tup](recursivelyApply: Boolean): Bijection[T, Tup] = macro CaseClassToTuple.caseClassToTupleImplWithOption[T, Tup]
+  def caseClassToMap[T: IsCaseClass](recursivelyApply: Boolean): Injection[T, Map[String, Any]] = macro CaseClassToMap.caseClassToMapImplWithOption[T]
+
+  /**
+   * This can be used like Inversion.attempt. For example:
+   * fastAttempt(intString)(intString.toInt)
+   * The reason we don't take a B => A like attempt does is
+   * that would still require calling apply on that function.
+   * In contrast, here, we can inline it directly.
+   */
+  def fastAttempt[A, B](b: B)(inv: A): Try[A] = macro TryMacros.fastAttempt[A, B]
+
+  /**
+   * This macro expands out to a try block so it is only slower
+   * than a try block in that it allocates Success/Failure wrappers
+   */
+  def fastTry[T](toEval: T): Try[T] = macro TryMacros.fastTry[T]
+}

bijection-macros/src/main/scala/com/twitter/bijection/macros/impl/CaseClassToMap.scala

@@ -0,0 +1,74 @@
+package com.twitter.bijection.macros.impl
+
+import scala.collection.mutable.{ Map => MMap }
+import scala.language.experimental.macros
+import scala.reflect.macros.Context
+import scala.reflect.runtime.universe._
+import scala.util.Try
+
+import com.twitter.bijection._
+import com.twitter.bijection.macros.{ IsCaseClass, MacroGenerated }
+
+private[bijection] object CaseClassToMap {
+  def caseClassToMapImplWithOption[T](c: Context)(recursivelyApply: c.Expr[Boolean])(proof: c.Expr[IsCaseClass[T]])(implicit T: c.WeakTypeTag[T]): c.Expr[Injection[T, Map[String, Any]]] = {
+    import c.universe._
+    recursivelyApply.tree match {
+      case q"""true""" => caseClassToMapNoProofImpl(c)(T)
+      case q"""false""" => caseClassToMapNoProofImplNonRecursive(c)(T)
+    }
+  }
+
+  def caseClassToMapImpl[T](c: Context)(proof: c.Expr[IsCaseClass[T]])(implicit T: c.WeakTypeTag[T]): c.Expr[Injection[T, Map[String, Any]]] =
+    caseClassToMapNoProofImpl(c)(T)
+
+  def caseClassToMapImplNonRecursive[T](c: Context)(proof: c.Expr[IsCaseClass[T]])(implicit T: c.WeakTypeTag[T]): c.Expr[Injection[T, Map[String, Any]]] =
+    caseClassToMapNoProofImplNonRecursive(c)(T)
+
+  def caseClassToMapNoProofImplNonRecursive[T](c: Context)(implicit T: c.WeakTypeTag[T]): c.Expr[Injection[T, Map[String, Any]]] = caseClassToMapNoProofImplCommon(c, false)(T)
+
+  // TODO the only diff between this and the above is the case match and the converters. it's easy to gate this on the boolean
+  def caseClassToMapNoProofImpl[T](c: Context)(implicit T: c.WeakTypeTag[T]): c.Expr[Injection[T, Map[String, Any]]] = caseClassToMapNoProofImplCommon(c, true)(T)
+
+  def caseClassToMapNoProofImplCommon[T](c: Context, recursivelyApply: Boolean)(implicit T: c.WeakTypeTag[T]): c.Expr[Injection[T, Map[String, Any]]] = {
+    import c.universe._
+    //TODO can make error handling better?
+    val companion = T.tpe.typeSymbol.companionSymbol
+
+    val getPutConv = T.tpe.declarations.collect { case m: MethodSymbol if m.isCaseAccessor => m }.zipWithIndex.map {
+      case (m, idx) =>
+        val returnType = m.returnType
+        val accStr = m.name.toTermName.toString
+        returnType match {
+          case tpe if recursivelyApply && IsCaseClassImpl.isCaseClassType(c)(tpe) =>
+            val conv = newTermName("c2m_" + idx)
+            (q"""$conv.invert(m($accStr).asInstanceOf[_root_.scala.collection.immutable.Map[String, Any]]).get""",
+              q"""($accStr, $conv(t.$m))""",
+              Some(q"""val $conv = implicitly[_root_.com.twitter.bijection.Injection[$tpe, _root_.scala.collection.immutable.Map[String, Any]]]""")) //TODO cache these
+          case tpe =>
+            (q"""m($accStr).asInstanceOf[$returnType]""",
+              q"""($accStr, t.$m)""",
+              None)
+        }
+    }
+
+    val getters = getPutConv.map(_._1)
+    val putters = getPutConv.map(_._2)
+    val converters = getPutConv.flatMap(_._3)
+
+    c.Expr[Injection[T, Map[String, Any]]](q"""
+    new Injection[$T, _root_.scala.collection.immutable.Map[String, Any]] with MacroGenerated {
+      override def apply(t: $T): _root_.scala.collection.immutable.Map[String, Any] = {
+        ..$converters
+        _root_.scala.collection.immutable.Map[String, Any](..$putters)
+      }
+      override def invert(m: _root_.scala.collection.immutable.Map[String, Any]): _root_.scala.util.Try[ $T ] = {
+        ..$converters
+        try { _root_.scala.util.Success($companion(..$getters)) }
+        catch { case _root_.scala.util.control.NonFatal(e) =>
+          _root_.scala.util.Failure(new _root_.com.twitter.bijection.InversionFailure(m, e)) }
+      }
+    }
+    """)
+
+  }
+}

bijection-macros/src/main/scala/com/twitter/bijection/macros/impl/CaseClassToTuple.scala

@@ -0,0 +1,86 @@
+package com.twitter.bijection.macros.impl
+
+import scala.collection.mutable.{ Map => MMap }
+import scala.language.experimental.macros
+import scala.reflect.macros.Context
+import scala.reflect.runtime.universe._
+import scala.util.Try
+
+import com.twitter.bijection._
+import com.twitter.bijection.macros.{ IsCaseClass, MacroGenerated }
+
+private[bijection] object CaseClassToTuple {
+  def caseClassToTupleImplWithOption[T, Tup](c: Context)(recursivelyApply: c.Expr[Boolean])(proof: c.Expr[IsCaseClass[T]])(implicit T: c.WeakTypeTag[T], Tup: c.WeakTypeTag[Tup]): c.Expr[Bijection[T, Tup]] = {
+    import c.universe._
+    recursivelyApply match {
+      case q"""true""" => caseClassToTupleNoProofImpl(c)(T, Tup)
+      case q"""false""" => caseClassToTupleNoProofImplNonRecursive(c)(T, Tup)
+      case _ => caseClassToTupleNoProofImpl(c)(T, Tup)
+    }
+  }
+
+  // Entry point
+  def caseClassToTupleImpl[T, Tup](c: Context)(proof: c.Expr[IsCaseClass[T]])(implicit T: c.WeakTypeTag[T], Tup: c.WeakTypeTag[Tup]): c.Expr[Bijection[T, Tup]] =
+    caseClassToTupleNoProofImpl(c)(T, Tup)
+
+  def caseClassToTupleImplNonRecursive[T, Tup](c: Context)(proof: c.Expr[IsCaseClass[T]])(implicit T: c.WeakTypeTag[T], Tup: c.WeakTypeTag[Tup]): c.Expr[Bijection[T, Tup]] =
+    caseClassToTupleNoProofImplNonRecursive(c)(T, Tup)
+
+  def caseClassToTupleNoProofImplNonRecursive[T, Tup](c: Context)(implicit T: c.WeakTypeTag[T],
+    Tup: c.WeakTypeTag[Tup]): c.Expr[Bijection[T, Tup]] =
+    caseClassToTupleNoProofImplCommon(c, false)(T, Tup)
+
+  def caseClassToTupleNoProofImpl[T, Tup](c: Context)(implicit T: c.WeakTypeTag[T],
+    Tup: c.WeakTypeTag[Tup]): c.Expr[Bijection[T, Tup]] =
+    caseClassToTupleNoProofImplCommon(c, true)(T, Tup)
+
+  def caseClassToTupleNoProofImplCommon[T, Tup](c: Context,
+    recursivelyApply: Boolean)(implicit T: c.WeakTypeTag[T],
+      Tup: c.WeakTypeTag[Tup]): c.Expr[Bijection[T, Tup]] = {
+    import c.universe._
+    val tupUtils = new TupleUtils[c.type](c)
+    val convCache = MMap.empty[Type, TermName]
+
+    //TODO can make error handling better
+    val companion = T.tpe.typeSymbol.companionSymbol
+    val getPutConv = T.tpe
+      .declarations
+      .collect { case m: MethodSymbol if m.isCaseAccessor => m }
+      .zip(tupUtils.tupleCaseClassEquivalent(T.tpe))
+      .zip(Tup.tpe.declarations.collect { case m: MethodSymbol if m.isCaseAccessor => m })
+      .zipWithIndex
+      .map {
+        case (((tM, treeEquiv), tupM), idx) =>
+          tM.returnType match {
+            case tpe if recursivelyApply && IsCaseClassImpl.isCaseClassType(c)(tpe) =>
+              val needDeclaration = !convCache.contains(tpe)
+              val conv = convCache.getOrElseUpdate(tpe, newTermName("c2t_" + idx))
+              (q"""$conv.invert(tup.$tupM)""",
+                q"""$conv(t.$tM)""",
+                if (needDeclaration) Some(q"""val $conv = implicitly[_root_.com.twitter.bijection.Bijection[${tM.returnType}, $treeEquiv]]""") else None) // cache these
+            case tpe =>
+              (q"""tup.$tupM""",
+                q"""t.$tM""",
+                None)
+          }
+      }
+
+    val getters = getPutConv.map(_._1)
+    val putters = getPutConv.map(_._2)
+    val converters = getPutConv.flatMap(_._3)
+
+    c.Expr[Bijection[T, Tup]](q"""
+    new Bijection[$T,$Tup] with MacroGenerated {
+      override def apply(t: $T): $Tup = {
+        ..$converters
+        (..$putters)
+      }
+      override def invert(tup: $Tup): $T = {
+        ..$converters
+        $companion(..$getters)
+      }
+    }
+    """)
+  }
+}
+//TODO test serialization of them

bijection-macros/src/main/scala/com/twitter/bijection/macros/impl/IsCaseClassImpl.scala

@@ -0,0 +1,29 @@
+package com.twitter.bijection.macros.impl
+
+import scala.language.experimental.macros
+import scala.reflect.macros.Context
+import scala.reflect.runtime.universe._
+import scala.util.{ Try => BasicTry }
+
+import com.twitter.bijection.macros.{ IsCaseClass, MacroGenerated }
+
+object IsCaseClassImpl {
+  def isCaseClassImpl[T](c: Context)(implicit T: c.WeakTypeTag[T]): c.Expr[IsCaseClass[T]] = {
+    import c.universe._
+    if (isCaseClassType(c)(T.tpe)) {
+      //TOOD we should support this, just need to make sure it is concrete
+      if (T.tpe.typeConstructor.takesTypeArgs) {
+        c.abort(c.enclosingPosition, "Case class with type parameters currently not supported")
+      } else {
+        c.Expr[IsCaseClass[T]](q"""_root_.com.twitter.bijection.macros.impl.MacroGeneratedIsCaseClass[$T]()""")
+      }
+    } else {
+      c.abort(c.enclosingPosition, "Type parameter is not a case class")
+    }
+  }
+
+  def isCaseClassType(c: Context)(tpe: c.universe.Type): Boolean =
+    BasicTry { tpe.typeSymbol.asClass.isCaseClass }.toOption.getOrElse(false)
+}
+
+case class MacroGeneratedIsCaseClass[T]() extends IsCaseClass[T] with MacroGenerated