add withResources pattern

Author: fupelaqu

build.sbt

@@ -30,7 +30,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "generic-persistence-api"
 
-ThisBuild / version := "0.3.5.1"
+ThisBuild / version := "0.3.5.2"
 
 ThisBuild / scalaVersion := "2.12.11"
 

common/src/main/scala/app/softnetwork/io/package.scala

@@ -3,7 +3,36 @@ package app.softnetwork
 import java.io.InputStream
 import scala.io.Source
 import scala.language.implicitConversions
+import scala.util.control.NonFatal
 
 package object io {
   implicit def inputStreamToString(is: InputStream): String = Source.fromInputStream(is).mkString
+
+  def withResources[T <: AutoCloseable, V](r: => T)(f: T => V): V = {
+    val resource: T = r
+    require(resource != null, "resource is null")
+    var exception: Throwable = null
+    try {
+      f(resource)
+    } catch {
+      case NonFatal(e) =>
+        exception = e
+        throw e
+    } finally {
+      closeAndAddSuppressed(exception, resource)
+    }
+  }
+
+  private def closeAndAddSuppressed(e: Throwable, resource: AutoCloseable): Unit = {
+    if (e != null) {
+      try {
+        resource.close()
+      } catch {
+        case NonFatal(suppressed) =>
+          e.addSuppressed(suppressed)
+      }
+    } else {
+      resource.close()
+    }
+  }
 }

common/src/main/scala/app/softnetwork/utils/Base64Tools.scala

@@ -13,8 +13,8 @@ object Base64Tools {
   def encodeBase64(bytes: Array[Byte], mimeType: Option[String] = None): String = {
     val encoded = Base64.encodeBase64String(bytes)
     mimeType match {
-      case Some(_) => s"data:$mimeType;base64,$encoded"
-      case _       => encoded
+      case Some(value) => s"data:$value;base64,$encoded"
+      case _           => encoded
     }
   }
 

common/src/main/scala/app/softnetwork/utils/ImageTools.scala

@@ -1,5 +1,6 @@
 package app.softnetwork.utils
 
+import app.softnetwork.io.withResources
 import com.typesafe.scalalogging.StrictLogging
 
 import java.awt.Color
@@ -43,19 +44,18 @@ object ImageTools extends StrictLogging {
   def encodeImageBase64(path: Path, encodeAsURI: Boolean = false): Option[String] = {
     if (Option(path).isDefined) {
       import Base64Tools._
-      val bos = new ByteArrayOutputStream()
       Try {
         val mimeType = detectMimeType(path)
         val format = toFormat(mimeType)
-        ImageIO.write(ImageIO.read(Files.newInputStream(path)), format.getOrElse("jpeg"), bos)
-        val encoded = encodeBase64(bos.toByteArray, if (encodeAsURI) mimeType else None)
-        bos.close()
-        encoded
+        withResources(new ByteArrayOutputStream()) { bos =>
+          withResources(Files.newInputStream(path)) { inputStream =>
+            ImageIO.write(ImageIO.read(inputStream), format.getOrElse("jpeg"), bos)
+            encodeBase64(bos.toByteArray, if (encodeAsURI) mimeType else None)
+          }
+        }
       } match {
         case Success(s) => Some(s)
-        case Failure(_) =>
-          bos.close()
-          None
+        case Failure(_) => None
       }
     } else {
       None
@@ -79,9 +79,11 @@ object ImageTools extends StrictLogging {
                |${sizes.map(s => s"${s.width}x${s.height}").mkString(",")}""".stripMargin
           )
           Try(
-            Option(
-              ImageIO.read(Files.newInputStream(originalPath))
-            )
+            withResources(Files.newInputStream(originalPath)) { inputStream =>
+              Option(
+                ImageIO.read(inputStream)
+              )
+            }
           ) match {
             case Success(value) =>
               value match {
@@ -140,9 +142,11 @@ object ImageTools extends StrictLogging {
               !Files.exists(out) || originalPath.toFile.lastModified() > out.toFile.lastModified()
             ) {
               Try(
-                Option(
-                  ImageIO.read(Files.newInputStream(originalPath))
-                )
+                withResources(Files.newInputStream(originalPath)) { inputStream =>
+                  Option(
+                    ImageIO.read(inputStream)
+                  )
+                }
               ) match {
                 case Success(value) =>
                   value match {
@@ -203,7 +207,11 @@ object ImageTools extends StrictLogging {
 
       val dest = Scalr.resize(src, Scalr.Method.ULTRA_QUALITY, imgWidth, imgHeight)
       val dest2 = Scalr.move(dest, leftMargin, topMargin, width, height, Color.WHITE)
-      Try(ImageIO.write(dest2, format, Files.newOutputStream(out))) match {
+      Try(
+        withResources(Files.newOutputStream(out)) { outputStream =>
+          ImageIO.write(dest2, format, outputStream)
+        }
+      ) match {
         case Success(_) =>
         case Failure(f) =>
           logger.error(

common/src/test/scala/app/softnetwork/utils/ImageToolsSpec.scala

@@ -17,6 +17,11 @@ class ImageToolsSpec extends AnyWordSpecLike {
     "check if it is an image" in {
       assert(ImageTools.isAnImage(path))
     }
+    "encode an image as Base64" in {
+      val encoded = ImageTools.encodeImageBase64(path, encodeAsURI = true)
+      assert(encoded.nonEmpty)
+      assert(encoded.exists(_.startsWith("data:image/jpeg;base64,/")))
+    }
     "resize an image" in {
       val sizes = Seq(Icon)
       assert(ImageTools.generateImages(path, sizes))