refactor

Author: mpollmeier

gremlin-scala/src/main/scala/gremlin/scala/GremlinScala.scala

@@ -13,8 +13,7 @@ import java.util.{
   Map => JMap,
   Collection => JCollection,
   Iterator => JIterator,
-  Set => JSet,
-  UUID
+  Set => JSet
 }
 import java.util.stream.{Stream => JStream}
 
@@ -33,7 +32,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.{Bytecode, Path, Scope, Tr
 import org.apache.tinkerpop.gremlin.structure.{Direction, T}
 import shapeless.{::, HList, HNil}
 import shapeless.ops.hlist.{IsHCons, Mapper, Prepend, RightFolder, ToTraversable, Tupler}
-import shapeless.ops.tuple.{Prepend => TuplePrepend}
 import shapeless.ops.product.ToHList
 import shapeless.syntax.std.tuple._
 import scala.concurrent.duration.FiniteDuration
@@ -120,7 +118,7 @@ class GremlinScala[End](val traversal: GraphTraversal[_, End]) {
     GremlinScala[JMap[String, A], Labels](traversal.project(projectKey, otherProjectKeys: _*))
 
   def project[H <: Product](
-      builder: ProjectionBuilder[Nil.type] ⇒ ProjectionBuilder[H]): GremlinScala[H] =
+      builder: ProjectionBuilder[Nil.type] => ProjectionBuilder[H]): GremlinScala[H] =
     builder(ProjectionBuilder()).build(this)
 
   /** You might think that predicate should be `GremlinScala[End] => GremlinScala[Boolean]`,
@@ -1034,28 +1032,3 @@ class GremlinScala[End](val traversal: GraphTraversal[_, End]) {
     travs.map(_.apply(start).traversal)
 
 }
-
-class ProjectionBuilder[T <: Product] private[gremlin] (
-    labels: Seq[String],
-    addBy: GraphTraversal[_, JMap[String, Any]] ⇒ GraphTraversal[_, JMap[String, Any]],
-    buildResult: JMap[String, Any] ⇒ T) {
-
-  def apply[U, TR <: Product](by: By[U])(
-      implicit prepend: TuplePrepend.Aux[T, Tuple1[U], TR]): ProjectionBuilder[TR] = {
-    val label = UUID.randomUUID().toString
-    new ProjectionBuilder[TR](labels :+ label,
-                              addBy.andThen(by.apply),
-                              map ⇒ buildResult(map) :+ map.get(label).asInstanceOf[U])
-  }
-
-  def and[U, TR <: Product](by: By[U])(
-      implicit prepend: TuplePrepend.Aux[T, Tuple1[U], TR]): ProjectionBuilder[TR] = apply(by)
-
-  private[gremlin] def build(g: GremlinScala[_]): GremlinScala[T] = {
-    GremlinScala(addBy(g.traversal.project(labels.head, labels.tail: _*))).map(buildResult)
-  }
-}
-
-object ProjectionBuilder {
-  def apply() = new ProjectionBuilder[Nil.type](Nil, scala.Predef.identity, _ ⇒ Nil)
-}

gremlin-scala/src/main/scala/gremlin/scala/ProjectionBuilder.scala

@@ -0,0 +1,31 @@
+package gremlin.scala
+
+import java.util.{Map => JMap, UUID}
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal
+import shapeless.ops.tuple.{Prepend => TuplePrepend}
+import shapeless.syntax.std.tuple._
+
+class ProjectionBuilder[T <: Product] private[gremlin] (
+    labels: Seq[String],
+    addBy: GraphTraversal[_, JMap[String, Any]] => GraphTraversal[_, JMap[String, Any]],
+    buildResult: JMap[String, Any] => T) {
+
+  def apply[U, TR <: Product](by: By[U])(
+      implicit prepend: TuplePrepend.Aux[T, Tuple1[U], TR]): ProjectionBuilder[TR] = {
+    val label = UUID.randomUUID().toString
+    new ProjectionBuilder[TR](labels :+ label,
+                              addBy.andThen(by.apply),
+                              map => buildResult(map) :+ map.get(label).asInstanceOf[U])
+  }
+
+  def and[U, TR <: Product](by: By[U])(
+      implicit prepend: TuplePrepend.Aux[T, Tuple1[U], TR]): ProjectionBuilder[TR] = apply(by)
+
+  private[gremlin] def build(g: GremlinScala[_]): GremlinScala[T] = {
+    GremlinScala(addBy(g.traversal.project(labels.head, labels.tail: _*))).map(buildResult)
+  }
+}
+
+object ProjectionBuilder {
+  def apply() = new ProjectionBuilder[Nil.type](Nil, scala.Predef.identity, _ => Nil)
+}