trailing commas

Author: Roman Janusz

commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/typed/TypedClientSession.scala

@@ -23,7 +23,7 @@ class TypedClientSession(val nativeSession: ClientSession)
     nativeSession.getTransactionOptions
 
   def startTransaction(
-    transactionOptions: TransactionOptions = TransactionOptions.builder().build()
+    transactionOptions: TransactionOptions = TransactionOptions.builder().build(),
   ): Unit =
     nativeSession.startTransaction(transactionOptions)
 
@@ -39,9 +39,9 @@ class TypedClientSession(val nativeSession: ClientSession)
     * error is propagated. The transaction is also aborted upon cancellation.
     */
   def inTransaction[T](
-    transactionOptions: TransactionOptions = TransactionOptions.builder().build()
+    transactionOptions: TransactionOptions = TransactionOptions.builder().build(),
   )(
-    task: Task[T]
+    task: Task[T],
   ): Task[T] = Task.defer {
     startTransaction(transactionOptions)
     task.guaranteeCase {

commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/typed/TypedMongoClient.scala

@@ -44,7 +44,7 @@ object TypedMongoClient {
   */
 class TypedMongoClient(
   val nativeClient: MongoClient,
-  val clientSession: OptArg[TypedClientSession] = OptArg.Empty
+  val clientSession: OptArg[TypedClientSession] = OptArg.Empty,
 ) extends TypedMongoUtils with Closeable {
   private val sessionOrNull = clientSession.toOpt.map(_.nativeSession).orNull
 
@@ -66,7 +66,7 @@ class TypedMongoClient(
   //TODO: `watch` methods
 
   def startSession(
-    options: ClientSessionOptions = ClientSessionOptions.builder().build()
+    options: ClientSessionOptions = ClientSessionOptions.builder().build(),
   ): Task[TypedClientSession] =
     single(nativeClient.startSession(options)).map(new TypedClientSession(_))
 
@@ -78,9 +78,9 @@ class TypedMongoClient(
     * returned copy of these objects.
     */
   def inSession[T](
-    options: ClientSessionOptions = ClientSessionOptions.builder().build()
+    options: ClientSessionOptions = ClientSessionOptions.builder().build(),
   )(
-    task: TypedClientSession => Task[T]
+    task: TypedClientSession => Task[T],
   ): Task[T] =
     startSession(options).bracket(task)(s => Task(s.close()))
 
@@ -97,7 +97,7 @@ class TypedMongoClient(
     sessionOptions: ClientSessionOptions = ClientSessionOptions.builder().build(),
     transactionOptions: TransactionOptions = TransactionOptions.builder().build(),
   )(
-    task: TypedClientSession => Task[T]
+    task: TypedClientSession => Task[T],
   ): Task[T] =
     inSession(sessionOptions)(s => s.inTransaction(transactionOptions)(task(s)))
 

commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/typed/TypedMongoCollection.scala

@@ -20,18 +20,18 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
   docCollection: MongoCollection[BsonDocument],
   val clientSession: Opt[TypedClientSession],
 )(implicit
-  meta: MongoEntityMeta[E]
+  meta: MongoEntityMeta[E],
 ) extends DataTypeDsl[E] with TypedMongoUtils {
 
   def this(
     rawCollection: MongoCollection[_],
-    clientSession: OptArg[TypedClientSession] = OptArg.Empty
+    clientSession: OptArg[TypedClientSession] = OptArg.Empty,
   )(implicit
-    meta: MongoEntityMeta[E]
+    meta: MongoEntityMeta[E],
   ) = this(
     TypedMongoCollection.mkNativeCollection[E](rawCollection),
     rawCollection.withDocumentClass(classOf[BsonDocument]),
-    clientSession.toOpt
+    clientSession.toOpt,
   )
 
   type ID = E#IDType
@@ -98,51 +98,51 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
 
   def renameCollection(
     namespace: MongoNamespace,
-    setupOptions: RenameCollectionOptions => RenameCollectionOptions = identity
+    setupOptions: RenameCollectionOptions => RenameCollectionOptions = identity,
   ): Task[Unit] =
     empty(optionalizeFirstArg(
-      nativeCollection.renameCollection(sessionOrNull, namespace, setupOptions(new RenameCollectionOptions))
+      nativeCollection.renameCollection(sessionOrNull, namespace, setupOptions(new RenameCollectionOptions)),
     ))
 
   def countDocuments(
     filter: MongoDocumentFilter[E] = MongoFilter.empty,
-    setupOptions: CountOptions => CountOptions = identity
+    setupOptions: CountOptions => CountOptions = identity,
   ): Task[Long] =
     single(optionalizeFirstArg(
-      nativeCollection.countDocuments(sessionOrNull, filter.toBson, setupOptions(new CountOptions))
+      nativeCollection.countDocuments(sessionOrNull, filter.toBson, setupOptions(new CountOptions)),
     )).asInstanceOf[Task[Long]]
 
   def estimatedDocumentCount(
-    setupOptions: EstimatedDocumentCountOptions => EstimatedDocumentCountOptions = identity
+    setupOptions: EstimatedDocumentCountOptions => EstimatedDocumentCountOptions = identity,
   ): Task[Long] =
     single(nativeCollection.estimatedDocumentCount(setupOptions(new EstimatedDocumentCountOptions)))
       .asInstanceOf[Task[Long]]
 
   def exists(
     filter: MongoDocumentFilter[E],
-    setupOptions: CountOptions => CountOptions = identity
+    setupOptions: CountOptions => CountOptions = identity,
   ): Task[Boolean] =
     countDocuments(filter, options => setupOptions(options).limit(1)).map(_ > 0)
 
   def findById(
     id: ID,
-    setupOptions: FindPublisher[Any] => FindPublisher[Any] = identity
+    setupOptions: FindPublisher[Any] => FindPublisher[Any] = identity,
   ): Task[Option[E]] =
     findOne(IdRef === id, setupOptions = setupOptions)
 
   def findOne[T](
     filter: MongoDocumentFilter[E] = MongoFilter.empty,
     projection: MongoProjection[E, T] = SelfRef,
     sort: MongoDocumentOrder[E] = MongoDocumentOrder.unspecified,
-    setupOptions: FindPublisher[Any] => FindPublisher[Any] = identity
+    setupOptions: FindPublisher[Any] => FindPublisher[Any] = identity,
   ): Task[Option[T]] =
     find(filter, projection, sort, o => setupOptions(o).limit(1)).firstOptionL
 
   def find[T](
     filter: MongoDocumentFilter[E] = MongoFilter.empty,
     projection: MongoProjection[E, T] = SelfRef,
     sort: MongoDocumentOrder[E] = MongoDocumentOrder.unspecified,
-    setupOptions: FindPublisher[Any] => FindPublisher[Any] = identity
+    setupOptions: FindPublisher[Any] => FindPublisher[Any] = identity,
   ): Observable[T] = {
 
     def setupPublisher[T0](publisher: FindPublisher[T0]): FindPublisher[T0] = {
@@ -171,7 +171,7 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
     projection: MongoProjection[E, T] = SelfRef,
     sort: MongoDocumentOrder[E] = MongoDocumentOrder.unspecified,
     upsert: Boolean = false, // extracted as separate param because it's very commonly used
-    setupOptions: FindOneAndUpdateOptions => FindOneAndUpdateOptions = identity
+    setupOptions: FindOneAndUpdateOptions => FindOneAndUpdateOptions = identity,
   ): Task[Option[T]] = {
     val filterBson = filter.toFilterBson(Opt.Empty, projection.projectionRefs)
     val options = setupOptions(new FindOneAndUpdateOptions).sort(sort.toBson).upsert(upsert)
@@ -182,12 +182,12 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
     projection match {
       case SelfRef =>
         singleOpt(optionalizeFirstArg(
-          nativeCollection.findOneAndUpdate(sessionOrNull, filterBson, updateBson, options)
+          nativeCollection.findOneAndUpdate(sessionOrNull, filterBson, updateBson, options),
         ).asInstanceOf[Publisher[T]])
       case proj =>
         val optionsWithProj = options.projection(proj.toProjectionBson)
         singleOpt(optionalizeFirstArg(
-          docCollection.findOneAndUpdate(sessionOrNull, filterBson, updateBson, optionsWithProj)
+          docCollection.findOneAndUpdate(sessionOrNull, filterBson, updateBson, optionsWithProj),
         )).map(_.map(proj.decodeFrom))
     }
   }
@@ -198,20 +198,20 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
     projection: MongoProjection[E, T] = SelfRef,
     sort: MongoDocumentOrder[E] = MongoDocumentOrder.unspecified,
     upsert: Boolean = false, // extracted as separate param because it's very commonly used
-    setupOptions: FindOneAndReplaceOptions => FindOneAndReplaceOptions = identity
+    setupOptions: FindOneAndReplaceOptions => FindOneAndReplaceOptions = identity,
   ): Task[Option[T]] = {
     val filterBson = filter.toFilterBson(Opt.Empty, projection.projectionRefs)
     val options = setupOptions(new FindOneAndReplaceOptions).sort(sort.toBson).upsert(upsert)
     projection match {
       case SelfRef =>
         singleOpt(optionalizeFirstArg(
-          nativeCollection.findOneAndReplace(sessionOrNull, filterBson, replacement, options)
+          nativeCollection.findOneAndReplace(sessionOrNull, filterBson, replacement, options),
         ).asInstanceOf[Publisher[T]])
       case proj =>
         val replaceDoc = format.writeBson(replacement).asDocument
         val optionsWithProj = options.projection(proj.toProjectionBson)
         singleOpt(optionalizeFirstArg(
-          docCollection.findOneAndReplace(sessionOrNull, filterBson, replaceDoc, optionsWithProj)
+          docCollection.findOneAndReplace(sessionOrNull, filterBson, replaceDoc, optionsWithProj),
         )).map(_.map(proj.decodeFrom))
     }
   }
@@ -220,27 +220,27 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
     filter: MongoDocumentFilter[E],
     projection: MongoProjection[E, T] = SelfRef,
     sort: MongoDocumentOrder[E] = MongoDocumentOrder.unspecified,
-    setupOptions: FindOneAndDeleteOptions => FindOneAndDeleteOptions = identity
+    setupOptions: FindOneAndDeleteOptions => FindOneAndDeleteOptions = identity,
   ): Task[Option[T]] = {
     val filterBson = filter.toFilterBson(Opt.Empty, projection.projectionRefs)
     val options = setupOptions(new FindOneAndDeleteOptions).sort(sort.toBson)
     projection match {
       case SelfRef =>
         singleOpt(optionalizeFirstArg(
-          nativeCollection.findOneAndDelete(sessionOrNull, filterBson, options)
+          nativeCollection.findOneAndDelete(sessionOrNull, filterBson, options),
         ).asInstanceOf[Publisher[T]])
       case proj =>
         val optionsWithProj = options.projection(proj.toProjectionBson)
         singleOpt(optionalizeFirstArg(
-          docCollection.findOneAndDelete(sessionOrNull, filterBson, optionsWithProj))
+          docCollection.findOneAndDelete(sessionOrNull, filterBson, optionsWithProj)),
         ).map(_.map(proj.decodeFrom))
     }
   }
 
   def distinct[T](
     property: MongoPropertyRef[E, T],
     filter: MongoDocumentFilter[E] = MongoFilter.empty,
-    setupOptions: DistinctPublisher[Any] => DistinctPublisher[Any] = identity
+    setupOptions: DistinctPublisher[Any] => DistinctPublisher[Any] = identity,
   ): Observable[T] = {
 
     val publisher =
@@ -255,104 +255,104 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
 
   def insertOne(
     value: E,
-    setupOptions: InsertOneOptions => InsertOneOptions = identity
+    setupOptions: InsertOneOptions => InsertOneOptions = identity,
   ): Task[InsertOneResult] =
     single(optionalizeFirstArg(
-      nativeCollection.insertOne(sessionOrNull, value, setupOptions(new InsertOneOptions))
+      nativeCollection.insertOne(sessionOrNull, value, setupOptions(new InsertOneOptions)),
     ))
 
   def insertMany(
     values: Seq[E],
-    setupOptions: InsertManyOptions => InsertManyOptions = identity
+    setupOptions: InsertManyOptions => InsertManyOptions = identity,
   ): Task[InsertManyResult] =
     single(optionalizeFirstArg(
-      nativeCollection.insertMany(sessionOrNull, values.asJava, setupOptions(new InsertManyOptions))
+      nativeCollection.insertMany(sessionOrNull, values.asJava, setupOptions(new InsertManyOptions)),
     ))
 
   def deleteOne(
     filter: MongoDocumentFilter[E],
-    setupOptions: DeleteOptions => DeleteOptions = identity
+    setupOptions: DeleteOptions => DeleteOptions = identity,
   ): Task[DeleteResult] =
     single(optionalizeFirstArg(
-      nativeCollection.deleteOne(sessionOrNull, filter.toBson, setupOptions(new DeleteOptions))
+      nativeCollection.deleteOne(sessionOrNull, filter.toBson, setupOptions(new DeleteOptions)),
     ))
 
   def deleteMany(
     filter: MongoDocumentFilter[E],
-    setupOptions: DeleteOptions => DeleteOptions = identity
+    setupOptions: DeleteOptions => DeleteOptions = identity,
   ): Task[DeleteResult] =
     single(optionalizeFirstArg(
-      nativeCollection.deleteMany(sessionOrNull, filter.toBson, setupOptions(new DeleteOptions))
+      nativeCollection.deleteMany(sessionOrNull, filter.toBson, setupOptions(new DeleteOptions)),
     ))
 
   def updateOne(
     filter: MongoDocumentFilter[E],
     update: MongoDocumentUpdate[E],
     upsert: Boolean = false, // extracted as separate param because it's very commonly used
-    setupOptions: UpdateOptions => UpdateOptions = identity
+    setupOptions: UpdateOptions => UpdateOptions = identity,
   ): Task[UpdateResult] = {
     val options = setupOptions(new UpdateOptions).upsert(upsert)
     val (updateBson, arrayFilters) = update.toBsonAndArrayFilters
     if (!arrayFilters.isEmpty) {
       options.arrayFilters(arrayFilters)
     }
     single(optionalizeFirstArg(
-      nativeCollection.updateOne(sessionOrNull, filter.toBson, updateBson, options)
+      nativeCollection.updateOne(sessionOrNull, filter.toBson, updateBson, options),
     ))
   }
 
   def updateMany(
     filter: MongoDocumentFilter[E],
     update: MongoDocumentUpdate[E],
     upsert: Boolean = false, // extracted as separate param because it's very commonly used
-    setupOptions: UpdateOptions => UpdateOptions = identity
+    setupOptions: UpdateOptions => UpdateOptions = identity,
   ): Task[UpdateResult] = {
     val options = setupOptions(new UpdateOptions).upsert(upsert)
     val (updateBson, arrayFilters) = update.toBsonAndArrayFilters
     if (!arrayFilters.isEmpty) {
       options.arrayFilters(arrayFilters)
     }
     single(optionalizeFirstArg(
-      nativeCollection.updateMany(sessionOrNull, filter.toBson, updateBson, options)
+      nativeCollection.updateMany(sessionOrNull, filter.toBson, updateBson, options),
     ))
   }
 
   def replaceOne(
     filter: MongoDocumentFilter[E],
     replacement: E,
     upsert: Boolean = false, // extracted as separate param because it's very commonly used
-    setupOptions: ReplaceOptions => ReplaceOptions = identity
+    setupOptions: ReplaceOptions => ReplaceOptions = identity,
   ): Task[UpdateResult] = {
     val options = setupOptions(new ReplaceOptions).upsert(upsert)
     single(optionalizeFirstArg(
-      nativeCollection.replaceOne(sessionOrNull, filter.toBson, replacement, options)
+      nativeCollection.replaceOne(sessionOrNull, filter.toBson, replacement, options),
     ))
   }
 
   def bulkWrite(
     writes: Seq[MongoWrite[E]],
-    setupOptions: BulkWriteOptions => BulkWriteOptions = identity
+    setupOptions: BulkWriteOptions => BulkWriteOptions = identity,
   ): Task[BulkWriteResult] = {
     val requests = writes.iterator.map(_.toWriteModel).to(JList)
     single(optionalizeFirstArg(
-      nativeCollection.bulkWrite(sessionOrNull, requests, setupOptions(new BulkWriteOptions))
+      nativeCollection.bulkWrite(sessionOrNull, requests, setupOptions(new BulkWriteOptions)),
     ))
   }
 
   def createIndex(index: MongoIndex[E]): Task[String] =
     single(optionalizeFirstArg(
-      nativeCollection.createIndex(sessionOrNull, index.toBson, index.setupOptions(new IndexOptions))
+      nativeCollection.createIndex(sessionOrNull, index.toBson, index.setupOptions(new IndexOptions)),
     ))
 
   def createIndexes(
     indexes: Seq[MongoIndex[E]],
-    setupOptions: CreateIndexOptions => CreateIndexOptions = identity
+    setupOptions: CreateIndexOptions => CreateIndexOptions = identity,
   ): Task[String] = {
     val indexModels = indexes.iterator
       .map(index => new IndexModel(index.toBson, index.setupOptions(new IndexOptions)))
       .to(JList)
     single(optionalizeFirstArg(
-      nativeCollection.createIndexes(sessionOrNull, indexModels, setupOptions(new CreateIndexOptions))
+      nativeCollection.createIndexes(sessionOrNull, indexModels, setupOptions(new CreateIndexOptions)),
     ))
   }
 
@@ -365,9 +365,9 @@ class TypedMongoCollection[E <: BaseMongoEntity] private(
 
 object TypedMongoCollection {
   private def mkNativeCollection[E <: BaseMongoEntity : MongoEntityMeta](
-    rawCollection: MongoCollection[_]
+    rawCollection: MongoCollection[_],
   )(implicit
-    meta: MongoEntityMeta[E]
+    meta: MongoEntityMeta[E],
   ): MongoCollection[E] = {
     import meta.format._
     val codecRegistry: CodecRegistry = GenCodecRegistry.create[E](rawCollection.getCodecRegistry)

commons-mongo/jvm/src/main/scala/com/avsystem/commons/mongo/typed/TypedMongoDatabase.scala

@@ -58,7 +58,7 @@ class TypedMongoDatabase(
     setupOptions: CreateCollectionOptions => CreateCollectionOptions = identity,
   ): Task[Unit] =
     empty(optionalizeFirstArg(
-      nativeDatabase.createCollection(sessionOrNull, name, setupOptions(new CreateCollectionOptions))
+      nativeDatabase.createCollection(sessionOrNull, name, setupOptions(new CreateCollectionOptions)),
     ))
 
   //TODO: `createView`, `watch`, `aggregate`