Upgrade to Scala v2.13

Key challenges with the upgrade:

* The [`scala-io`](https://github.com/jesseeichar/scala-io) library is not
  available for Scala 2.13 (I had custom-built the Scala 2.12 version, but it
  was too much effort to get it to 2.13). `scala-io` was providing several
  useful features:
  * streaming reading of character data with line-splitting that *preserves
    line-breaks* (because I don't want the BFG to change the line-breaks in
    your files while doing `--replace-text`). Finding a replacement library to
    do this wasn't easy - so much code seems to be based on
    `java.io.BufferedReader`, which throws line-breaks away. `java.util.Scanner`    can _maybe_ do it, but I couldn't get it to work! In the end, I implemented
    my own solution, a tiny library with a fairly decent set of tests:
    https://github.com/rtyley/line-break-preserving-line-splitting
  * resource management - mostly replaced by using Scala 2.13's
    [`Using`](https://www.scala-lang.org/api/current/scala/util/Using$.html).
  * File-path types and operations - mostly now performed by java.nio & Guava
    functions.
* Scala 2.13 has a [revised collections framework](https://docs.scala-lang.org/overviews/core/collections-migration-213.html), so:
  * BFG has its own `ConcurrentSet` which needs to be implemented in the new
    fashion
  * `Traversable` becomes `Iterable`, etc

Author: rtyley

.travis.yml

@@ -1,7 +1,7 @@
 language: scala
 dist: xenial
 scala:
-   - 2.12.12
+   - 2.13.4
 
 jdk:
   - openjdk8

bfg-benchmark/build.sbt

@@ -2,7 +2,6 @@ import Dependencies._
 
 libraryDependencies ++= Seq(
   madgagCompress,
-  scalaIoFile,
   textmatching,
   scopt
 )

bfg-library/build.sbt

@@ -1,4 +1,14 @@
 import Dependencies._
 
-libraryDependencies ++= guava :+ scalaIoFile :+ textmatching :+ scalaGit :+ jgit :+ slf4jSimple :+ scalaGitTest % "test"
+libraryDependencies ++= guava ++ Seq(
+  parCollections,
+  scalaCollectionPlus,
+  textmatching,
+  scalaGit,
+  jgit,
+  slf4jSimple,
+  lineSplitting,
+  scalaGitTest % Test,
+  "org.apache.commons" % "commons-text" % "1.9" % Test
+)
 

bfg-library/src/main/scala/com/madgag/collection/concurrent/ConcurrentMultiMap.scala

@@ -20,6 +20,7 @@
 
 package com.madgag.collection.concurrent
 
+import com.madgag.scala.collection.decorators._
 
 class ConcurrentMultiMap[A, B] {
 
@@ -34,5 +35,5 @@ class ConcurrentMultiMap[A, B] {
     this
   }
 
-  def toMap: Map[A, Set[B]] = m.toMap.mapValues(_.toSet)
+  def toMap: Map[A, Set[B]] = m.toMap.mapV(_.toSet)
 }

bfg-library/src/main/scala/com/madgag/collection/concurrent/ConcurrentSet.scala

@@ -20,29 +20,53 @@
 
 package com.madgag.collection.concurrent
 
-import scala.collection.mutable.{Set, SetLike}
+import scala.collection.mutable.{AbstractSet, SetOps}
+import scala.collection.{IterableFactory, IterableFactoryDefaults, mutable}
 
-
-class ConcurrentSet[A] extends Set[A] with SetLike[A, ConcurrentSet[A]] {
+class ConcurrentSet[A]()
+  extends AbstractSet[A]
+    with SetOps[A, ConcurrentSet, ConcurrentSet[A]]
+    with IterableFactoryDefaults[A, ConcurrentSet]
+{
 
   val m: collection.concurrent.Map[A, Boolean] = collection.concurrent.TrieMap.empty
 
-  override def +=(elem: A): this.type = {
+  override def iterableFactory: IterableFactory[ConcurrentSet] = ConcurrentSet
+
+  override def clear(): Unit = m.clear()
+
+  override def addOne(elem: A): ConcurrentSet.this.type = {
     m.put(elem, true)
     this
   }
 
-  override def -=(elem: A): this.type = {
+  override def subtractOne(elem: A): ConcurrentSet.this.type = {
     m.remove(elem)
     this
   }
 
-  override def empty: this.type = {
-    m.empty
-    this
-  }
-
   override def contains(elem: A): Boolean = m.contains(elem)
 
   override def iterator: Iterator[A] = m.keysIterator
+
+}
+
+object ConcurrentSet extends IterableFactory[ConcurrentSet] {
+
+  @transient
+  private final val EmptySet = new ConcurrentSet()
+
+  def empty[A]: ConcurrentSet[A] = EmptySet.asInstanceOf[ConcurrentSet[A]]
+
+  def from[A](source: collection.IterableOnce[A]): ConcurrentSet[A] =
+    source match {
+      case hs: ConcurrentSet[A] => hs
+      case _ if source.knownSize == 0 => empty[A]
+      case _ => (newBuilder[A] ++= source).result()
+    }
+
+  /** Create a new Builder which can be reused after calling `result()` without an
+   * intermediate call to `clear()` in order to build multiple related results.
+   */
+  def newBuilder[A]: mutable.Builder[A, ConcurrentSet[A]] = ???
 }

bfg-library/src/main/scala/com/madgag/git/LFS.scala

@@ -20,34 +20,34 @@
 
 package com.madgag.git
 
-import java.nio.charset.Charset
-import java.security.{DigestOutputStream, MessageDigest}
-
 import com.google.common.base.Splitter
 import com.madgag.git.bfg.model.FileName
 import org.apache.commons.codec.binary.Hex._
 import org.eclipse.jgit.lib.ObjectLoader
 
-import scala.collection.JavaConverters._
-import scalax.file.Path
-import scalax.file.defaultfs.DefaultPath
+import java.nio.charset.Charset
+import java.nio.charset.StandardCharsets.UTF_8
+import java.nio.file.{Files, Path}
+import java.security.{DigestOutputStream, MessageDigest}
+import scala.jdk.CollectionConverters._
+import scala.util.Using
 
 object LFS {
 
-  val ObjectsPath = Path("lfs" , "objects")
+  val ObjectsPath: Seq[String] = Seq("lfs" , "objects")
 
-  val PointerCharset = Charset.forName("UTF-8")
+  val PointerCharset: Charset = UTF_8
 
   case class Pointer(shaHex: String, blobSize: Long) {
 
-    lazy val text = s"""|version https://git-lfs.github.com/spec/v1
-                        |oid sha256:$shaHex
-                        |size $blobSize
-                        |""".stripMargin
+    lazy val text: String = s"""|version https://git-lfs.github.com/spec/v1
+                                |oid sha256:$shaHex
+                                |size $blobSize
+                                |""".stripMargin
 
-    lazy val bytes = text.getBytes(PointerCharset)
+    lazy val bytes: Array[Byte] = text.getBytes(PointerCharset)
 
-    lazy val path = Path(shaHex.substring(0, 2), shaHex.substring(2, 4), shaHex)
+    lazy val path: Seq[String] = Seq(shaHex.substring(0, 2), shaHex.substring(2, 4), shaHex)
   }
 
   object Pointer {
@@ -65,12 +65,12 @@ object LFS {
 
   val GitAttributesFileName = FileName(".gitattributes")
 
-  def pointerFor(loader: ObjectLoader, tmpFile: DefaultPath) = {
+  def pointerFor(loader: ObjectLoader, tmpFile: Path) = {
     val digest = MessageDigest.getInstance("SHA-256")
 
-    for {
-      outStream <- tmpFile.outputStream()
-    } loader.copyTo(new DigestOutputStream(outStream, digest))
+    Using(Files.newOutputStream(tmpFile)) { outStream =>
+      loader.copyTo(new DigestOutputStream(outStream, digest))
+    }
 
     Pointer(encodeHexString(digest.digest()), loader.getSize)
   }

bfg-library/src/main/scala/com/madgag/git/bfg/GitUtil.scala

@@ -30,9 +30,11 @@ import org.eclipse.jgit.lib._
 import org.eclipse.jgit.revwalk.RevWalk
 import org.eclipse.jgit.storage.file.WindowCacheConfig
 
-import scala.collection.convert.ImplicitConversionsToScala._
+import scala.jdk.CollectionConverters._
+import scala.jdk.StreamConverters._
 import scala.language.implicitConversions
 
+
 trait CleaningMapper[V] extends Cleaner[V] {
   def isDirty(v: V) = apply(v) != v
 
@@ -51,7 +53,7 @@ object GitUtil {
 
   val ProbablyNoNonFileObjectsOverSizeThreshold: Long = 1024 * 1024
 
-  def tweakStaticJGitConfig(massiveNonFileObjects: Option[Long]) {
+  def tweakStaticJGitConfig(massiveNonFileObjects: Option[Long]): Unit = {
     val wcConfig: WindowCacheConfig = new WindowCacheConfig()
     wcConfig.setStreamFileThreshold(Ints.saturatedCast(massiveNonFileObjects.getOrElse(ProbablyNoNonFileObjectsOverSizeThreshold)))
     wcConfig.install()
@@ -62,22 +64,22 @@ object GitUtil {
     implicit val revWalk = new RevWalk(repo)
     implicit val objectReader = revWalk.getObjectReader
 
-    repo.getAllRefs.values.map(_.getObjectId).filter(_.open.getType == Constants.OBJ_COMMIT)
-      .map(_.asRevCommit).exists(_.getFooterLines(FormerCommitFooter.Key).nonEmpty)
+    repo.getAllRefs.values().stream().toScala(Seq).map(_.getObjectId).filter(_.open.getType == Constants.OBJ_COMMIT)
+      .map(_.asRevCommit).exists(_.getFooterLines(FormerCommitFooter.Key).asScala.nonEmpty)
   }
 
   implicit def cleaner2CleaningMapper[V](f: Cleaner[V]): CleaningMapper[V] = new CleaningMapper[V] {
     def apply(v: V) = f(v)
   }
 
-  def biggestBlobs(implicit objectDB: ObjectDirectory, progressMonitor: ProgressMonitor = NullProgressMonitor.INSTANCE): Stream[SizedObject] = {
+  def biggestBlobs(implicit objectDB: ObjectDirectory, progressMonitor: ProgressMonitor = NullProgressMonitor.INSTANCE): LazyList[SizedObject] = {
     Timing.measureTask("Scanning packfile for large blobs", ProgressMonitor.UNKNOWN) {
       val reader = objectDB.newReader
       objectDB.packedObjects.map {
             objectId =>
               progressMonitor update 1
               SizedObject(objectId, reader.getObjectSize(objectId, OBJ_ANY))
-          }.toSeq.sorted.reverse.toStream.filter { oid =>
+          }.toSeq.sorted.reverse.to(LazyList).filter { oid =>
         oid.size > ProbablyNoNonFileObjectsOverSizeThreshold || reader.open(oid.objectId).getType == OBJ_BLOB
       }
     }

bfg-library/src/main/scala/com/madgag/git/bfg/cleaner/BlobCharsetDetector.scala

@@ -20,36 +20,38 @@
 
 package com.madgag.git.bfg.cleaner
 
-import java.nio.ByteBuffer
-import java.nio.charset.Charset
-import java.nio.charset.CodingErrorAction._
-
+import com.google.common.io.ByteStreams
+import com.google.common.io.ByteStreams.toByteArray
 import com.madgag.git.bfg.model.TreeBlobEntry
 import org.eclipse.jgit.diff.RawText
-import org.eclipse.jgit.lib.ObjectStream
+import org.eclipse.jgit.lib.ObjectLoader
 
-import scala.util.Try
-import scalax.io.managed.InputStreamResource
+import java.nio.ByteBuffer
+import java.nio.charset.Charset
+import java.nio.charset.CodingErrorAction._
+import scala.util.{Try, Using}
 
 
 trait BlobCharsetDetector {
   // should return None if this is a binary file that can not be converted to text
-  def charsetFor(entry: TreeBlobEntry, streamResource: InputStreamResource[ObjectStream]): Option[Charset]
+  def charsetFor(entry: TreeBlobEntry, objectLoader: ObjectLoader): Option[Charset]
 }
 
 
 object QuickBlobCharsetDetector extends BlobCharsetDetector {
 
-  val CharSets = Seq(Charset.forName("UTF-8"), Charset.defaultCharset(), Charset.forName("ISO-8859-1")).distinct
+  val CharSets: Seq[Charset] =
+    Seq(Charset.forName("UTF-8"), Charset.defaultCharset(), Charset.forName("ISO-8859-1")).distinct
 
-  def charsetFor(entry: TreeBlobEntry, streamResource: InputStreamResource[ObjectStream]): Option[Charset] =
-    Some(streamResource.bytes.take(8000).toArray).filterNot(RawText.isBinary).flatMap {
+  def charsetFor(entry: TreeBlobEntry, objectLoader: ObjectLoader): Option[Charset] = {
+    Using(ByteStreams.limit(objectLoader.openStream(), 8000))(toByteArray).toOption.filterNot(RawText.isBinary).flatMap {
       sampleBytes =>
         val b = ByteBuffer.wrap(sampleBytes)
         CharSets.find(cs => Try(decode(b, cs)).isSuccess)
     }
+  }
 
-  private def decode(b: ByteBuffer, charset: Charset) {
+  private def decode(b: ByteBuffer, charset: Charset): Unit = {
     charset.newDecoder.onMalformedInput(REPORT).onUnmappableCharacter(REPORT).decode(b)
   }
 }

bfg-library/src/main/scala/com/madgag/git/bfg/cleaner/BlobTextModifier.scala

@@ -20,13 +20,14 @@
 
 package com.madgag.git.bfg.cleaner
 
-import java.io.ByteArrayOutputStream
-
 import com.madgag.git.ThreadLocalObjectDatabaseResources
 import com.madgag.git.bfg.model.TreeBlobEntry
+import com.madgag.linesplitting.LineBreakPreservingIterator
 import org.eclipse.jgit.lib.Constants.OBJ_BLOB
+import org.eclipse.jgit.lib.ObjectLoader
 
-import scalax.io.Resource
+import java.io.{ByteArrayOutputStream, InputStreamReader}
+import java.nio.charset.Charset
 
 
 object BlobTextModifier {
@@ -50,17 +51,13 @@ trait BlobTextModifier extends TreeBlobModifier {
     def filterTextIn(e: TreeBlobEntry, lineCleaner: String => String): TreeBlobEntry = {
       def isDirty(line: String) = lineCleaner(line) != line
 
+      val loader = threadLocalObjectDBResources.reader().open(e.objectId)
       val opt = for {
-        loader         <- Some(threadLocalObjectDBResources.reader().open(e.objectId))
-        if loader.getSize < sizeThreshold
-        streamResource <- Some(Resource.fromInputStream(loader.openStream()))
-        charset        <- charsetDetector.charsetFor(e, streamResource)
-        reader         <- Some(streamResource.reader(charset))
-        lines = reader.lines(includeTerminator = true)
-        if lines.exists(isDirty)
+        charset <- charsetDetector.charsetFor(e, loader)
+        if loader.getSize < sizeThreshold && linesFor(loader, charset).exists(isDirty)
       } yield {
         val b = new ByteArrayOutputStream(loader.getSize.toInt)
-        lines.view.map(lineCleaner).foreach(line => b.write(line.getBytes(charset)))
+        linesFor(loader, charset).map(lineCleaner).foreach(line => b.write(line.getBytes(charset)))
         val oid = threadLocalObjectDBResources.inserter().insert(OBJ_BLOB, b.toByteArray)
         e.copy(objectId = oid)
       }
@@ -73,4 +70,8 @@ trait BlobTextModifier extends TreeBlobModifier {
       case None => entry.withoutName
     }
   }
+
+  private def linesFor(loader: ObjectLoader, charset: Charset): Iterator[String] = {
+    new LineBreakPreservingIterator(new InputStreamReader(loader.openStream(), charset))
+  }
 }