1.4.0 RELEASE

Author: sfxcode

CHANGES.md

@@ -2,6 +2,10 @@
 
 ## Versions
 
+### 1.4.0
+*  dropped operations with pattern <name>Result (use headResult, list result or implicit conversion instead)
+
+
 ### 1.3.1
 * update mongo-scala-driver to 2.4.0
 * Operations Base count method support CountOptions

README.md

@@ -71,28 +71,76 @@ object RestaurantDatabase {
 
 ```
 
+Import the database object and execute some find and CRUD functions on the DAO object ...
 
-Import the database object and execute find and CRUD functions on the DAO object.
+```scala
+
+import com.sfxcode.nosql.mongo.demo.restaurant.RestaurantDemoDatabase._
+import com.sfxcode.nosql.mongo._
+
+trait RestaurantDemoDatabaseFunctions {
+
+  /**
+   * single result with implicit conversion to Entity Option
+   */
+  def findRestaurantByName(name: String): Option[Restaurant] =
+    RestaurantDAO.find("name", name)
+
+  def restaurantsSize: Long = RestaurantDAO.count()
+
+  /**
+   * result with implicit conversion to List of Entities
+   */
+  def findAllRestaurants(filterValues: Map[String, Any] = Map()): List[Restaurant] =
+    RestaurantDAO.find(filterValues)
+
+```
+
+
+Use the mongodb functions in your app ...
 
 ```scala
- import RestaurantDatabase._
+ object RestaurantDemoApp extends App with RestaurantDemoDatabaseFunctions {
 
- import com.sfxcode.nosql.mongo._
+   // find specific restaurant by name as Option Result
+   val restaurant = findRestaurantByName("Dj Reynolds Pub And Restaurant")
 
- object RestaurantApp extends App {
+   println(restaurant)
 
-   val restaurant: Option[Restaurant] = RestaurantDAO.find("name", "Dj Reynolds Pub And Restaurant")
+   // use count function
+   println(restaurantsSize)
 
-   println(restaurant.get.grades)
- 
-   val restaurants: List[Restaurant] = RestaurantDAO.find(Map("address.zipcode" -> "10075", "cuisine" -> "Italian"))
+   // find restaurants by filter
+   private val filter = Map("address.zipcode" -> "10075", "cuisine" -> "Italian")
+   val restaurants = findAllRestaurants(filter)
 
    restaurants.sortBy(r => r.name).foreach(r => println(r.name))
 
  }
 
 ```
 
+Write some spec tests ...
+
+````scala
+import com.sfxcode.nosql.mongo.demo.restaurant.RestaurantDemoDatabase._
+import org.specs2.mutable.Specification
+
+class RestaurantDemoSpec extends Specification with RestaurantDemoDatabaseFunctions {
+
+  "RestaurantDemo" should {
+
+    "find restaurant by name in" in {
+
+      val restaurantSearch = findRestaurantByName("Dj Reynolds Pub And Restaurant")
+      restaurantSearch must beSome[Restaurant]
+      val restaurant = restaurantSearch.get
+      restaurant.borough must be equalTo "Manhattan"
+    }
+  }
+
+}
+```
 
 
 

src/main/paradox/index.md

@@ -30,6 +30,7 @@ Documentation for [MongoDB](https://docs.mongodb.com/)
 
  - [Tutorial Setup](tutorial/setup.md)
  - [Tutorial Database](tutorial/database.md)
+ - [Tutorial Functions](tutorial/functions.md)
  - [Tutorial Application](tutorial/application.md)
  - [MongoDAO Overview](dao/mongo_dao.md)
  - [MongoDAO Base](dao/base.md)

src/main/paradox/tutorial/application.md

@@ -1,14 +1,9 @@
-# Tutorial Part 3 - Application
+# Tutorial Part 4 - Application
 
 ## Info
 
 This Demo Application should demonstrate the basic usage of simple-mongo.
 
-## Imports
-
-@@snip [RestaurantDatabase.scala](../../../test/scala/com/sfxcode/nosql/mongo/demo/restaurant/RestaurantDemoDatabase.scala) { #import }
-
-
 ## Simple Application
 
 @@snip [RestaurantApp](../../../test/scala/com/sfxcode/nosql/mongo/demo/restaurant/RestaurantDemoApp.scala) { #app }

src/main/paradox/tutorial/functions.md

@@ -0,0 +1,15 @@
+# Tutorial Part 3 - Functions
+
+## Info
+
+Use a functions trait to define some commonly used funtions.
+
+## Imports
+
+@@snip [RestaurantDemoDatabaseFunctions.scala](../../../test/scala/com/sfxcode/nosql/mongo/demo/restaurant/RestaurantDemoDatabaseFunctions.scala) { #import }
+
+
+## Simple Application
+
+@@snip [RestaurantDemoDatabaseFunctions](../../../test/scala/com/sfxcode/nosql/mongo/demo/restaurant/RestaurantDemoDatabaseFunctions.scala) { #trait }
+

src/main/scala/com/sfxcode/nosql/mongo/operation/Base.scala

@@ -1,10 +1,9 @@
 package com.sfxcode.nosql.mongo.operation
 
-import com.sfxcode.nosql.mongo._
 import com.typesafe.scalalogging.LazyLogging
 import org.mongodb.scala.bson.conversions.Bson
-import org.mongodb.scala.model.{ CountOptions, IndexOptions }
 import org.mongodb.scala.model.Sorts._
+import org.mongodb.scala.model.{ CountOptions, IndexOptions }
 import org.mongodb.scala.{ Completed, Document, MongoCollection, Observable, Observer, SingleObservable }
 
 import scala.reflect.ClassTag
@@ -13,35 +12,23 @@ abstract class Base[A]()(implicit ct: ClassTag[A]) extends LazyLogging {
 
   protected def coll: MongoCollection[A]
 
-  def count(filter: Bson = Document(), options: CountOptions = CountOptions()): Observable[Long] = coll.countDocuments(filter)
-
-  def countResult(filter: Bson = Document(), options: CountOptions = CountOptions()): Long = count(filter, options)
+  def count(filter: Bson = Document(), options: CountOptions = CountOptions()): Observable[Long] = coll.countDocuments(filter, options)
 
   def drop(): Observable[Completed] = coll.drop()
 
-  def dropResult(): Completed = drop().headResult()
-
   def createIndexForField(field: String, sortAscending: Boolean = true): SingleObservable[String] = {
     if (sortAscending)
       createIndex(ascending(field))
     else
       createIndex(descending(field))
   }
 
-  def createIndexForFieldResult(field: String, sortAscending: Boolean = true): String = createIndexForField(field, sortAscending)
-
   def createIndex(key: Bson, options: IndexOptions = IndexOptions()): SingleObservable[String] = coll.createIndex(key, options)
 
-  def createsIndexResult(key: Bson, options: IndexOptions = IndexOptions()): String = createIndex(key, options)
-
   def dropIndexForName(name: String): SingleObservable[Completed] = coll.dropIndex(name)
 
-  def dropIndexForNameResult(name: String): Completed = dropIndexForName(name)
-
   def dropIndex(keys: Bson): SingleObservable[Completed] = coll.dropIndex(keys)
 
-  def dropIndexResult(keys: Bson): Completed = dropIndex(keys)
-
 }
 
 class SimpleCompletedObserver[T] extends Observer[T] with LazyLogging {

src/main/scala/com/sfxcode/nosql/mongo/operation/Crud.scala

@@ -14,20 +14,12 @@ abstract class Crud[A]()(implicit ct: ClassTag[A]) extends Base[A] {
   // create
   def insertOne(value: A): Observable[Completed] = coll.insertOne(value)
 
-  def insertOneResult(value: A): Completed = coll.insertOne(value)
-
   def insertOne(value: A, options: InsertOneOptions): Observable[Completed] = coll.insertOne(value, options)
 
-  def insertOneResult(value: A, options: InsertOneOptions): Completed = insertOne(value, options)
-
   def insertMany(values: Seq[A]): Observable[Completed] = coll.insertMany(values)
 
-  def insertManyResult(values: Seq[A]): Completed = insertMany(values)
-
   def insertMany(values: Seq[A], options: InsertManyOptions): Observable[Completed] = coll.insertMany(values, options)
 
-  def insertManyResult(values: Seq[A], options: InsertManyOptions): Completed = insertMany(values, options)
-
   // update
 
   def replaceOne(value: A): Observable[UpdateResult] = {
@@ -36,81 +28,47 @@ abstract class Crud[A]()(implicit ct: ClassTag[A]) extends Base[A] {
     coll.replaceOne(equal("_id", oid), value)
   }
 
-  def replaceOneResult(value: A): UpdateResult = replaceOne(value)
-
   def replaceOne(value: A, options: ReplaceOptions): Observable[UpdateResult] = {
     val document = Converter.toDocument(value)
     val oid = document.get("_id").get
     coll.replaceOne(equal("_id", oid), value, options)
   }
 
-  def replaceOneResult(value: A, options: ReplaceOptions): UpdateResult = replaceOne(value, options)
-
   def replaceOne(filter: Bson, value: A): Observable[UpdateResult] =
     coll.replaceOne(filter, value)
 
-  def replaceOneResult(filter: Bson, value: A): UpdateResult = replaceOne(filter, value)
-
   def replaceOne(filter: Bson, value: A, options: ReplaceOptions): Observable[UpdateResult] =
     coll.replaceOne(filter, value, options)
 
-  def replaceOneResult(filter: Bson, value: A, options: ReplaceOptions): UpdateResult = replaceOne(filter, value, options)
-
   def updateOne(filter: Bson, update: Bson): Observable[UpdateResult] =
     coll.updateOne(filter, update)
 
-  def updateOneResult(filter: Bson, update: Bson): UpdateResult =
-    updateOne(filter, update)
-
   def updateOne(filter: Bson, update: Bson, options: UpdateOptions): Observable[UpdateResult] =
     coll.updateOne(filter, update, options)
 
-  def updateOneResult(filter: Bson, update: Bson, options: UpdateOptions): UpdateResult =
-    updateOne(filter, update, options)
-
   def updateMany(filter: Bson, update: Bson): Observable[UpdateResult] =
     coll.updateMany(filter, update)
 
-  def updateManyResult(filter: Bson, update: Bson): UpdateResult =
-    updateMany(filter, update)
-
   def updateMany(filter: Bson, update: Bson, options: UpdateOptions): Observable[UpdateResult] =
     coll.updateMany(filter, update, options)
 
-  def updateManyResult(filter: Bson, update: Bson, options: UpdateOptions): UpdateResult =
-    updateMany(filter, update, options)
-
   // delete
 
   def deleteOne(filter: Bson): Observable[DeleteResult] = coll.deleteOne(filter)
 
-  def deleteOneResult(filter: Bson): DeleteResult = deleteOne(filter)
-
   def deleteOne(filter: Bson, options: DeleteOptions): Observable[DeleteResult] = coll.deleteOne(filter, options)
 
-  def deleteOneResult(filter: Bson, options: DeleteOptions): DeleteResult = deleteOne(filter, options)
-
   def deleteOne(value: A): Observable[DeleteResult] = {
     val oid = Converter.toDocument(value).get("_id").get
     coll.deleteOne(equal("_id", oid))
   }
 
-  def deleteOneResult(value: A): DeleteResult = deleteOne(value)
-
   def deleteMany(filter: Bson): Observable[DeleteResult] = coll.deleteMany(filter)
 
-  def deleteManyResult(filter: Bson): DeleteResult = deleteMany(filter)
-
   def deleteMany(filter: Bson, options: DeleteOptions): Observable[DeleteResult] = coll.deleteMany(filter, options)
 
-  def deleteManyResult(filter: Bson, options: DeleteOptions): DeleteResult = deleteMany(filter, options)
-
   def deleteAll(): Observable[DeleteResult] = deleteMany(Map())
 
-  def deleteAllResult(): DeleteResult = deleteAll()
-
   def deleteAll(options: DeleteOptions): Observable[DeleteResult] = deleteMany(Map(), options)
 
-  def deleteAllResult(options: DeleteOptions): DeleteResult = deleteAll(options)
-
 }

src/test/scala/com/sfxcode/nosql/mongo/TestDatabase.scala

@@ -28,14 +28,15 @@ object TestDatabase extends ObservableImplicits {
 
   object PersonDAO extends MongoDAO[Person](database, "person")
 
-  PersonDAO.dropResult()
+  val dropResult: Completed = PersonDAO.drop()
 
   val persons: List[Person] = Person.personList
 
-  PersonDAO.insertMany(persons).head()
+  val insertResult: Completed = PersonDAO.insertMany(persons)
 
   def printDatabaseStatus(): Unit = {
-    printDebugValues("Database Status", "%s rows for collection person found".format(PersonDAO.countResult()))
+    val count: Long = PersonDAO.count()
+    printDebugValues("Database Status", "%s rows for collection person found".format(count))
   }
 
   def printDebugValues(name: String, result: Any): Unit = {

src/test/scala/com/sfxcode/nosql/mongo/demo/restaurant/RestaurantDemoApp.scala

@@ -1,25 +1,20 @@
 package com.sfxcode.nosql.mongo.demo.restaurant
 
-// #import
-// static import of needed DAO objects
-import com.sfxcode.nosql.mongo.demo.restaurant.RestaurantDemoDatabase._
+// #app
 
-// static import of mongo package object for needed implicits
-import com.sfxcode.nosql.mongo._
-// #import
+object RestaurantDemoApp extends App with RestaurantDemoDatabaseFunctions {
 
-// #app
+  // find specific restaurant by name as Option Result
+  val restaurant = findRestaurantByName("Dj Reynolds Pub And Restaurant")
 
-object RestaurantDemoApp extends App {
-  // find specific restaurant key and value as Option Result
-  val restaurant = RestaurantDAO.find("name", "Dj Reynolds Pub And Restaurant")
+  println(restaurant)
 
-  println(restaurant.get)
+  // use count function
+  println(restaurantsSize)
 
+  // find restaurants by filter
   private val filter = Map("address.zipcode" -> "10075", "cuisine" -> "Italian")
-  // find restaurants by filter - use implicit map to document conversion
-  // as List result
-  val restaurants: List[Restaurant] = RestaurantDAO.find(filter)
+  val restaurants = findAllRestaurants(filter)
 
   restaurants.sortBy(r => r.name).foreach(r => println(r.name))
 

src/test/scala/com/sfxcode/nosql/mongo/demo/restaurant/RestaurantDemoDatabaseFunctions.scala

@@ -0,0 +1,31 @@
+package com.sfxcode.nosql.mongo.demo.restaurant
+
+// #import
+// static import of needed DAO objects
+import com.sfxcode.nosql.mongo.demo.restaurant.RestaurantDemoDatabase._
+
+// static import of mongo package object for needed implicits
+import com.sfxcode.nosql.mongo._
+// #import
+
+// #trait
+
+trait RestaurantDemoDatabaseFunctions {
+
+  /**
+   * single result with implicit conversion to Entity Option
+   */
+  def findRestaurantByName(name: String): Option[Restaurant] =
+    RestaurantDAO.find("name", name)
+
+  def restaurantsSize: Long = RestaurantDAO.count()
+
+  /**
+   * result with implicit conversion to List of Entities
+   */
+  def findAllRestaurants(filterValues: Map[String, Any] = Map()): List[Restaurant] =
+    RestaurantDAO.find(filterValues)
+
+  // #trait
+
+}