WIP

.circleci/config.yml

@@ -1,26 +1,52 @@
-version: 2
+version: 2.1
+
+commands:
+  collect_test_reports:
+    description: Collect test reports
+    steps:
+      - run:
+          name: Collect test report
+          command: |
+                    mkdir test-reports
+                    find . -path '*/test-reports/*' -name '*.xml' \
+                      -print -exec cp {} test-reports \;
+          when: always
+
+  publish_snapshots:
+    description: Publish artifacts to Snapshots repository
+    steps:
+      - deploy:
+          name: Publish artifacts to Sonatype Snapshots
+          command: |
+                    if [ ! "${CIRCLE_BRANCH}" = "master" ]; then
+                      echo "Skipped on branch ${CIRCLE_BRANCH}"
+                      exit 0
+                    fi
+                    
+                    export PUBLISH_REPO_NAME="Sonatype Nexus Repository Manager"
+                    export PUBLISH_REPO_ID="oss.sonatype.org"
+                    export PUBLISH_REPO_URL="https://oss.sonatype.org/content/repositories/snapshots"
+                    
+                    if [ "x$PUBLISH_USER" = "x" -o "x$PUBLISH_PASS" = "x" ]; then
+                      echo "Missing publication credentials"
+                      exit 1
+                    fi
+                    
+                    sbt +publish
+
 jobs:
-  build:
+  build_n_tests:
     docker:
-      # specify the version you desire here
       - image: circleci/openjdk:8-jdk
 
     working_directory: ~/repo
 
-    environment:
-      # Customize the JVM maximum heap limit
-      JVM_OPTS: -Xmx3200m
-      TERM: dumb
-
     steps:
       - checkout
 
-      # Download and cache dependencies
       - restore_cache:
           keys:
-          - v1-dependencies-{{ checksum "build.sbt" }}
-          # fallback to using the latest cache if no exact match is found
-          - v1-dependencies-
+          - &scala_cache_key scala-{{ checksum "version.sbt" }}-{{ checksum "compiler.sbt" }}-{{ checksum "build.sbt" }}
 
       - run:
           name: Tests
@@ -29,7 +55,67 @@ jobs:
       - save_cache:
           paths:
             - ~/.ivy2
-          key: v1-dependencies--{{ checksum "build.sbt" }}
+            - ~/.coursier/cache
+            - ~/.sbt
+          key: *scala_cache_key
 
+      - collect_test_reports
       - store_test_results:
-          path: .
+          path: test-reports
+
+  publish_snapshots:
+    docker:
+      - image: circleci/openjdk:8-jdk
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      - restore_cache:
+          keys:
+          - *scala_cache_key
+
+      - publish_snapshots
+
+      - save_cache:
+          paths:
+            - ~/.ivy2
+            - ~/.coursier/cache
+            - ~/.sbt
+          key: *scala_cache_key
+
+  trigger_dependent_builds:
+    docker:
+      - image: cimg/base:2020.01
+
+    working_directory: ~/repo
+
+    steps:
+      - run:
+          name: Trigger build @ Reactivemongo-Site
+          command: |
+                    curl -X POST "https://circleci.com/api/v1.1/project/github/ReactiveMongo/reactivemongo-site/build?circle-token=${REACTIVEMONGO_SITE_API_TOKEN}"
+
+workflows:
+  version: 2
+
+  main_suite:
+    jobs:
+      - build_n_tests
+
+      - publish_snapshots:
+          filters:
+            branches:
+              only:
+                - master
+          requires:
+            - build_n_tests
+
+      - trigger_dependent_builds:
+          filters:
+            branches:
+              only:
+                - master
+          requires:
+            - publish_snapshots

input/src/main/scala/fix/ApiUsage.scala

@@ -0,0 +1,112 @@
+/*
+rule = ReactiveMongoUpgrade
+*/
+package fix
+
+import scala.concurrent.{ ExecutionContext, Future }
+
+import reactivemongo.api.{ MongoDriver, MongoConnection }
+import reactivemongo.api.commands.{ CollStatsResult, WriteConcern }
+
+import reactivemongo.api.commands.MultiBulkWriteResult
+
+import reactivemongo.api.collections.GenericCollection
+import reactivemongo.api.collections.bson.BSONCollection
+
+import com.github.ghik.silencer.silent
+
+object Commands {
+  def collStats(drv: MongoDriver, wc: WriteConcern): Future[CollStatsResult] = ???
+
+  def bulk: Future[MultiBulkWriteResult] = ???
+}
+
+object Drv {
+  def connect(d: MongoDriver) = d.connection("mongodb://...")
+
+  def closeCon(con: MongoConnection) = con.askClose()(null)
+
+  @silent
+  def conFromStr(uri: String)(implicit ec: ExecutionContext) =
+    MongoConnection.parseURI(uri)
+}
+
+object Coll {
+  import reactivemongo.bson.BSONDocument
+
+  @silent def rename1(coll: GenericCollection[_])(
+    implicit
+    ec: ExecutionContext) = coll.rename("foo")
+
+  @silent def rename2(coll: BSONCollection)(
+    implicit
+    ec: ExecutionContext) = coll.rename("foo", false)
+
+  def query1(coll: BSONCollection) = {
+    val qry = coll.find(BSONDocument.empty, BSONDocument("bar" -> 1)).
+      partial
+
+    val b = qry.sortOption
+    val c = qry.projectionOption
+    val d = qry.hintOption
+    val e = qry.explainFlag
+    val f = qry.snapshotFlag
+    val g = qry.commentString
+    val h = qry.maxTimeMsOption
+
+    if (System.currentTimeMillis() == -1) {
+      println(s"b=$b,c=$c,d=$d,e=$e,f=$f,g=$g,h=$h")
+    }
+  }
+
+  def query2(coll: BSONCollection) = coll.find(
+    projection = BSONDocument("lorem" -> 1),
+    selector = BSONDocument.empty)
+
+  @silent
+  def agg1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.aggregateWith1[BSONDocument](explain = true, true) { f =>
+      import f._
+
+      val m = Match(BSONDocument("foo" -> 1))
+      val _ = m.makePipe
+
+      m -> List(Out("bar"))
+    }
+
+  def agg2(coll: BSONCollection) = coll.BatchCommands.AggregationFramework
+
+  def remove1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.remove(BSONDocument("foo" -> 1))
+
+  def remove2(
+    coll: BSONCollection,
+    wc: WriteConcern)(implicit ec: ExecutionContext) = coll.remove(
+    firstMatchOnly = true,
+    selector = BSONDocument("foo" -> 1),
+    writeConcern = wc)
+
+  def insert1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.insert(BSONDocument("bar" -> 1))
+
+  def insert2(
+    coll: BSONCollection,
+    wc: WriteConcern)(implicit ec: ExecutionContext) =
+    coll.insert[BSONDocument](
+      writeConcern = wc,
+      document = BSONDocument("bar" -> 1))
+
+  def update1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.update[BSONDocument, BSONDocument](
+      BSONDocument("foo" -> 1), BSONDocument("bar" -> "lorem"))
+
+  def update2(coll: BSONCollection, wc: WriteConcern)(
+    implicit
+    ec: ExecutionContext) = coll.update(
+    writeConcern = wc,
+    update = BSONDocument("bar" -> "lorem"),
+    selector = BSONDocument("foo" -> 1),
+    multi = false,
+    upsert = true)
+
+}

input/src/main/scala/fix/LinterUsage.scala

@@ -5,12 +5,12 @@ package fix
 
 import scala.concurrent.Future
 
-import reactivemongo.api.{ DB, DefaultDB }
+import reactivemongo.api.DB
 
 object LinterUsage {
   val db1 = resolveDB // assert: ReactiveMongoLinter
 
   val db2: Future[DB] = db1
 
-  private def resolveDB: Future[DefaultDB] = ???
+  private def resolveDB: Future[DB] = ???
 }

output/src/main/scala/fix/ApiUsage.scala

@@ -0,0 +1,97 @@
+package fix
+
+import scala.concurrent.{ ExecutionContext, Future }
+
+import reactivemongo.api.MongoConnection
+
+
+import reactivemongo.api.collections.GenericCollection
+import reactivemongo.api.bson.collection.BSONCollection
+
+import com.github.ghik.silencer.silent
+import reactivemongo.api.{ AsyncDriver, CollectionStats, WriteConcern }
+import reactivemongo.api.bson.BSONDocument
+
+object Commands {
+  def collStats(drv: AsyncDriver, wc: WriteConcern): Future[CollectionStats] = ???
+
+  def bulk: Future[Any /* MultiBulkWriteResult ~> anyCollection.MultiBulkWriteResult */] = ???
+}
+
+object Drv {
+  def connect(d: AsyncDriver) = d.connect("mongodb://...")
+
+  def closeCon(con: MongoConnection) = con.close()(null)
+
+  @silent
+  def conFromStr(uri: String)(implicit ec: ExecutionContext) =
+    MongoConnection.fromString(uri)
+}
+
+object Coll {
+
+  @silent def rename1(coll: GenericCollection[_])(
+    implicit
+    ec: ExecutionContext) = coll.db.connection.database("admin").flatMap(_.renameCollection(coll.db.name, coll.name, "foo"))
+
+  @silent def rename2(coll: BSONCollection)(
+    implicit
+    ec: ExecutionContext) = coll.db.connection.database("admin").flatMap(_.renameCollection(coll.db.name, coll.name, "foo", false))
+
+  def query1(coll: BSONCollection) = {
+    val qry = coll.find(BSONDocument.empty, Some(BSONDocument("bar" -> 1))).
+      allowPartialResults
+
+    val b = qry.sort
+    val c = qry.projection
+    val d = qry.hint
+    val e = qry.explain
+    val f = qry.snapshot
+    val g = qry.comment
+    val h = qry.maxTimeMs
+
+    if (System.currentTimeMillis() == -1) {
+      println(s"b=$b,c=$c,d=$d,e=$e,f=$f,g=$g,h=$h")
+    }
+  }
+
+  def query2(coll: BSONCollection) = coll.find(selector = BSONDocument.empty, projection = Some(BSONDocument("lorem" -> 1)))
+
+  @silent
+  def agg1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.aggregateWith[BSONDocument](explain = true, true) { f =>
+      import f._
+
+      val m = Match(BSONDocument("foo" -> 1))
+      val _ = m
+
+      m -> List(Out("bar"))
+    }
+
+  def agg2(coll: BSONCollection) = coll.AggregationFramework
+
+  def remove1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.delete.one(q = BSONDocument("foo" -> 1))
+
+  def remove2(
+    coll: BSONCollection,
+    wc: WriteConcern)(implicit ec: ExecutionContext) = coll.delete(writeConcern = wc).one(q = BSONDocument("foo" -> 1), limit = {
+  if (true) Some(1) else None
+})
+
+  def insert1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.insert.one(BSONDocument("bar" -> 1))
+
+  def insert2(
+    coll: BSONCollection,
+    wc: WriteConcern)(implicit ec: ExecutionContext) =
+    coll.insert(writeConcern = wc).one[BSONDocument](BSONDocument("bar" -> 1))
+
+  def update1(coll: BSONCollection)(implicit ec: ExecutionContext) =
+    coll.update.one[BSONDocument, BSONDocument](q = BSONDocument("foo" -> 1), u = BSONDocument("bar" -> "lorem"))
+
+  def update2(coll: BSONCollection, wc: WriteConcern)(
+    implicit
+    ec: ExecutionContext) = coll.update(writeConcern = wc).one(q = BSONDocument("foo" -> 1), u = BSONDocument("bar" -> "lorem"), upsert = true, multi = false)
+
+}

output/src/main/scala/fix/Bson.scala

@@ -1,11 +1,9 @@
 package fix
 
-import reactivemongo.api.bson._
-import reactivemongo.api.bson.BSONValue
-import reactivemongo.api.bson.{ BSONDocument, BSONObjectID }
 
-import reactivemongo.api.bson.collection.BSONSerializationPack
 import reactivemongo.api.bson.collection.BSONCollection
+import reactivemongo.api.bson.{ BSONDocument, BSONObjectID, BSONValue, _ }
+import reactivemongo.api.bson.collection.BSONSerializationPack
 
 object Bson {
   @com.github.ghik.silencer.silent

output/src/main/scala/fix/LinterUsage.scala

@@ -2,12 +2,12 @@ package fix
 
 import scala.concurrent.Future
 
-import reactivemongo.api.{ DB, DefaultDB }
+import reactivemongo.api.DB
 
 object LinterUsage {
   val db1 = resolveDB 
 
   val db2: Future[DB] = db1
 
-  private def resolveDB: Future[DefaultDB] = ???
+  private def resolveDB: Future[DB] = ???
 }