Remove implicit EC definition in base DAO.

fehmicansaglam · Jul 25, 2014 · d816b94 · d816b94
1 parent dbd35b3
commit d816b94
Show file tree

Hide file tree

Showing 14 changed files with 90 additions and 85 deletions.
diff --git a/bson/src/main/scala/dao/BsonDao.scala b/bson/src/main/scala/dao/BsonDao.scala
@@ -17,7 +17,7 @@
 package reactivemongo.extensions.dao
 
 import scala.util.Random
-import scala.concurrent.{ Future, Await }
+import scala.concurrent.{ Future, Await, ExecutionContext }
 import scala.concurrent.duration._
 import reactivemongo.bson._
 import reactivemongo.api.{ bulk, DB, QueryOpts }
@@ -79,10 +79,11 @@ import Handlers._
 abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit modelReader: BSONDocumentReader[Model],
   modelWriter: BSONDocumentWriter[Model],
   idWriter: BSONWriter[ID, _ <: BSONValue],
-  lifeCycle: LifeCycle[Model, ID] = new ReflexiveLifeCycle[Model, ID])
+  lifeCycle: LifeCycle[Model, ID] = new ReflexiveLifeCycle[Model, ID],
+  ec: ExecutionContext)
     extends Dao[BSONCollection, BSONDocument, Model, ID, BSONDocumentWriter](db, collectionName) {
 
-  def ensureIndexes(): Future[Traversable[Boolean]] = Future sequence {
+  def ensureIndexes()(implicit ec: ExecutionContext): Future[Traversable[Boolean]] = Future sequence {
     autoIndexes map { index =>
       collection.indexesManager.ensure(index)
     }
@@ -91,27 +92,27 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
     results
   }
 
-  def listIndexes(): Future[List[Index]] = {
+  def listIndexes()(implicit ec: ExecutionContext): Future[List[Index]] = {
     collection.indexesManager.list()
   }
 
-  def findOne(selector: BSONDocument = BSONDocument.empty): Future[Option[Model]] = {
+  def findOne(selector: BSONDocument = BSONDocument.empty)(implicit ec: ExecutionContext): Future[Option[Model]] = {
     collection.find(selector).one[Model]
   }
 
-  def findById(id: ID): Future[Option[Model]] = {
+  def findById(id: ID)(implicit ec: ExecutionContext): Future[Option[Model]] = {
     findOne($id(id))
   }
 
-  def findByIds(ids: ID*): Future[List[Model]] = {
+  def findByIds(ids: ID*)(implicit ec: ExecutionContext): Future[List[Model]] = {
     findAll("_id" $in (ids: _*))
   }
 
   def find(
     selector: BSONDocument = BSONDocument.empty,
     sort: BSONDocument = BSONDocument("_id" -> 1),
     page: Int,
-    pageSize: Int): Future[List[Model]] = {
+    pageSize: Int)(implicit ec: ExecutionContext): Future[List[Model]] = {
     val from = (page - 1) * pageSize
     collection
       .find(selector)
@@ -123,7 +124,7 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
 
   def findAll(
     selector: BSONDocument = BSONDocument.empty,
-    sort: BSONDocument = BSONDocument("_id" -> 1)): Future[List[Model]] = {
+    sort: BSONDocument = BSONDocument("_id" -> 1))(implicit ec: ExecutionContext): Future[List[Model]] = {
     collection.find(selector).sort(sort).cursor[Model].collect[List]()
   }
 
@@ -132,7 +133,7 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
     update: BSONDocument,
     sort: BSONDocument = BSONDocument.empty,
     fetchNewObject: Boolean = false,
-    upsert: Boolean = false): Future[Option[Model]] = {
+    upsert: Boolean = false)(implicit ec: ExecutionContext): Future[Option[Model]] = {
     val command = FindAndModify(
       collection = collectionName,
       query = query,
@@ -143,7 +144,7 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
     collection.db.command(command).map(_.map(modelReader.read))
   }
 
-  def findAndRemove(query: BSONDocument, sort: BSONDocument = BSONDocument.empty): Future[Option[Model]] = {
+  def findAndRemove(query: BSONDocument, sort: BSONDocument = BSONDocument.empty)(implicit ec: ExecutionContext): Future[Option[Model]] = {
     val command = FindAndModify(
       collection = collectionName,
       query = query,
@@ -153,15 +154,15 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
     collection.db.command(command).map(_.map(modelReader.read))
   }
 
-  def findRandom(selector: BSONDocument = BSONDocument.empty): Future[Option[Model]] = {
+  def findRandom(selector: BSONDocument = BSONDocument.empty)(implicit ec: ExecutionContext): Future[Option[Model]] = {
     for {
       count <- count(selector)
       index = if (count == 0) 0 else Random.nextInt(count)
       random <- collection.find(selector).options(QueryOpts(skipN = index, batchSizeN = 1)).one[Model]
     } yield random
   }
 
-  def insert(model: Model, writeConcern: GetLastError = defaultWriteConcern): Future[LastError] = {
+  def insert(model: Model, writeConcern: GetLastError = defaultWriteConcern)(implicit ec: ExecutionContext): Future[LastError] = {
     val mappedModel = lifeCycle.prePersist(model)
     collection.insert(mappedModel, writeConcern) map { lastError =>
       lifeCycle.postPersist(mappedModel)
@@ -172,7 +173,7 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
   def bulkInsert(
     documents: TraversableOnce[Model],
     bulkSize: Int = bulk.MaxDocs,
-    bulkByteSize: Int = bulk.MaxBulkSize): Future[Int] = {
+    bulkByteSize: Int = bulk.MaxBulkSize)(implicit ec: ExecutionContext): Future[Int] = {
     val mappedDocuments = documents.map(lifeCycle.prePersist)
     val enumerator = Enumerator.enumerate(mappedDocuments)
     collection.bulkInsert(enumerator, bulkSize, bulkByteSize) map { result =>
@@ -186,38 +187,38 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
     update: U,
     writeConcern: GetLastError = defaultWriteConcern,
     upsert: Boolean = false,
-    multi: Boolean = false): Future[LastError] = {
+    multi: Boolean = false)(implicit ec: ExecutionContext): Future[LastError] = {
     collection.update(selector, update, writeConcern, upsert, multi)
   }
 
   def updateById[U: BSONDocumentWriter](
     id: ID,
     update: U,
-    writeConcern: GetLastError = defaultWriteConcern): Future[LastError] = {
+    writeConcern: GetLastError = defaultWriteConcern)(implicit ec: ExecutionContext): Future[LastError] = {
     collection.update($id(id), update, writeConcern)
   }
 
-  def save(model: Model, writeConcern: GetLastError = defaultWriteConcern): Future[LastError] = {
+  def save(model: Model, writeConcern: GetLastError = defaultWriteConcern)(implicit ec: ExecutionContext): Future[LastError] = {
     val mappedModel = lifeCycle.prePersist(model)
     collection.save(mappedModel, writeConcern) map { lastError =>
       lifeCycle.postPersist(mappedModel)
       lastError
     }
   }
 
-  def count(selector: BSONDocument = BSONDocument.empty): Future[Int] = {
+  def count(selector: BSONDocument = BSONDocument.empty)(implicit ec: ExecutionContext): Future[Int] = {
     collection.db.command(Count(collectionName, Some(selector)))
   }
 
-  def drop(): Future[Boolean] = {
+  def drop()(implicit ec: ExecutionContext): Future[Boolean] = {
     collection.drop()
   }
 
-  def dropSync(timeout: Duration = 10 seconds): Boolean = {
+  def dropSync(timeout: Duration = 10 seconds)(implicit ec: ExecutionContext): Boolean = {
     Await.result(drop(), timeout)
   }
 
-  def removeById(id: ID, writeConcern: GetLastError = defaultWriteConcern): Future[LastError] = {
+  def removeById(id: ID, writeConcern: GetLastError = defaultWriteConcern)(implicit ec: ExecutionContext): Future[LastError] = {
     lifeCycle.preRemove(id)
     collection.remove($id(id), writeConcern = defaultWriteConcern) map { lastError =>
       lifeCycle.postRemove(id)
@@ -228,17 +229,17 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
   def remove(
     query: BSONDocument,
     writeConcern: GetLastError = defaultWriteConcern,
-    firstMatchOnly: Boolean = false): Future[LastError] = {
+    firstMatchOnly: Boolean = false)(implicit ec: ExecutionContext): Future[LastError] = {
     collection.remove(query, writeConcern, firstMatchOnly)
   }
 
-  def removeAll(writeConcern: GetLastError = defaultWriteConcern): Future[LastError] = {
+  def removeAll(writeConcern: GetLastError = defaultWriteConcern)(implicit ec: ExecutionContext): Future[LastError] = {
     collection.remove(query = BSONDocument.empty, writeConcern = writeConcern, firstMatchOnly = false)
   }
 
   def foreach(
     selector: BSONDocument = BSONDocument.empty,
-    sort: BSONDocument = BSONDocument("_id" -> 1))(f: (Model) => Unit): Future[Unit] = {
+    sort: BSONDocument = BSONDocument("_id" -> 1))(f: (Model) => Unit)(implicit ec: ExecutionContext): Future[Unit] = {
     collection.find(selector).sort(sort).cursor[Model]
       .enumerate()
       .apply(Iteratee.foreach(f))
@@ -248,7 +249,7 @@ abstract class BsonDao[Model, ID](db: () => DB, collectionName: String)(implicit
   def fold[A](
     selector: BSONDocument = BSONDocument.empty,
     sort: BSONDocument = BSONDocument("_id" -> 1),
-    state: A)(f: (A, Model) => A): Future[A] = {
+    state: A)(f: (A, Model) => A)(implicit ec: ExecutionContext): Future[A] = {
     collection.find(selector).sort(sort).cursor[Model]
       .enumerate()
       .apply(Iteratee.fold(state)(f))

diff --git a/bson/src/test/scala/dao/CustomIdBsonDao.scala b/bson/src/test/scala/dao/CustomIdBsonDao.scala
@@ -16,6 +16,7 @@
 
 package reactivemongo.extensions.dao
 
+import scala.concurrent.ExecutionContext.Implicits.global
 import reactivemongo.extensions.model.CustomIdModel
 import reactivemongo.api.indexes.{ Index, IndexType }
 import reactivemongo.extensions.util.Misc.UUID

diff --git a/bson/src/test/scala/dao/DummyBsonDao.scala b/bson/src/test/scala/dao/DummyBsonDao.scala
@@ -16,6 +16,7 @@
 
 package reactivemongo.extensions.dao
 
+import scala.concurrent.ExecutionContext.Implicits.global
 import reactivemongo.extensions.model.DummyModel
 import reactivemongo.api.indexes.{ Index, IndexType }
 import reactivemongo.bson.BSONObjectID

diff --git a/bson/src/test/scala/dao/EventBsonDao.scala b/bson/src/test/scala/dao/EventBsonDao.scala
@@ -16,11 +16,12 @@
 
 package reactivemongo.extensions.dao
 
+import scala.concurrent.{ Future, Await }
+import scala.concurrent.duration._
+import scala.concurrent.ExecutionContext.Implicits.global
 import reactivemongo.extensions.model.Event
 import reactivemongo.api.DefaultDB
 import reactivemongo.extensions.dsl.BsonDsl
-import scala.concurrent.{ Future, Await }
-import scala.concurrent.duration._
 
 class EventBsonDao(_db: DefaultDB)
     extends BsonDao[Event, String](() => _db, "events")

diff --git a/bson/src/test/scala/dao/MapModelBsonDao.scala b/bson/src/test/scala/dao/MapModelBsonDao.scala
@@ -16,6 +16,7 @@
 
 package reactivemongo.extensions.dao
 
+import scala.concurrent.ExecutionContext.Implicits.global
 import reactivemongo.extensions.model.MapModel
 import reactivemongo.bson.BSONObjectID
 import reactivemongo.bson.DefaultBSONHandlers._

diff --git a/bson/src/test/scala/dao/PersonBsonDao.scala b/bson/src/test/scala/dao/PersonBsonDao.scala
@@ -21,6 +21,7 @@ import reactivemongo.api.DefaultDB
 import reactivemongo.extensions.dsl.BsonDsl
 import scala.concurrent.{ Future, Await }
 import scala.concurrent.duration._
+import scala.concurrent.ExecutionContext.Implicits.global
 
 class PersonBsonDao(_db: DefaultDB)
     extends BsonDao[Person, String](() => _db, "persons")

diff --git a/bson/src/test/scala/dao/TemporalModelDao.scala b/bson/src/test/scala/dao/TemporalModelDao.scala
@@ -16,12 +16,13 @@
 
 package reactivemongo.extensions.dao
 
+import scala.concurrent.{ Future, Await }
+import scala.concurrent.duration._
+import scala.concurrent.ExecutionContext.Implicits.global
 import reactivemongo.extensions.model.TemporalModel
 import reactivemongo.api.DefaultDB
 import reactivemongo.api.indexes.{ Index, IndexType }
 import reactivemongo.bson.BSONObjectID
-import scala.concurrent.{ Future, Await }
-import scala.concurrent.duration._
 import reactivemongo.extensions.util.Misc.UUID
 
 class TemporalModelDao