Use scalafmt and reformat code

TheHive-Project · May 3, 2019 · d91c757 · d91c757
1 parent 4f82da2
commit d91c757
Show file tree

Hide file tree

Showing 81 changed files with 2,135 additions and 1,850 deletions.
diff --git a/.scalafmt.conf b/.scalafmt.conf
@@ -0,0 +1,26 @@
+version = "2.0.0-RC7"
+align = more    # For pretty alignment.
+assumeStandardLibraryStripMargin = true
+style = defaultWithAlign
+maxColumn = 150
+
+align.openParenCallSite = false
+align.openParenDefnSite = false
+newlines.alwaysBeforeTopLevelStatements = true
+rewrite.rules = [
+  # ExpandImportSelectors
+  RedundantBraces
+  RedundantParens
+  SortModifiers
+  PreferCurlyFors
+  SortImports
+]
+
+includeCurlyBraceInSelectChains = true
+includeNoParensInSelectChains = true
+
+rewriteTokens {
+  "=>" : "⇒"
+  "<-" : "←"
+  "->": "→"
+}
diff --git a/app/org/elastic4play/ClientAuthSSLEngineProvider.scala b/app/org/elastic4play/ClientAuthSSLEngineProvider.scala
@@ -1,6 +1,6 @@
 package org.elastic4play
 
-import java.nio.file.{ Files, Paths }
+import java.nio.file.{Files, Paths}
 import java.security.KeyStore
 
 import play.api.Logger
@@ -12,48 +12,46 @@ import javax.net.ssl._
 
 class ClientAuthSSLEngineProvider(serverConfig: ServerConfig, appProvider: ApplicationProvider) extends SSLEngineProvider {
 
-  lazy val logger = Logger(getClass)
+  lazy val logger    = Logger(getClass)
   private val config = serverConfig.configuration
 
   def readKeyManagers(): Array[KeyManager] = {
-    val keyStorePath = Paths.get(config.get[String]("play.server.https.keyStore.path"))
-    val keyStoreType = config.getOptional[String]("play.server.https.keyStore.type").getOrElse(KeyStore.getDefaultType)
+    val keyStorePath     = Paths.get(config.get[String]("play.server.https.keyStore.path"))
+    val keyStoreType     = config.getOptional[String]("play.server.https.keyStore.type").getOrElse(KeyStore.getDefaultType)
     val keyStorePassword = config.getOptional[String]("play.server.https.keyStore.password").getOrElse("").toCharArray
-    val keyInputStream = Files.newInputStream(keyStorePath)
+    val keyInputStream   = Files.newInputStream(keyStorePath)
     try {
       val keyStore = KeyStore.getInstance(keyStoreType)
       keyStore.load(keyInputStream, keyStorePassword)
       val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm)
       kmf.init(keyStore, keyStorePassword)
       kmf.getKeyManagers
-    }
-    finally {
+    } finally {
       keyInputStream.close()
     }
   }
 
-  def readTrustManagers(): Array[TrustManager] = {
-    config.getOptional[String]("play.server.https.trustStore.path")
+  def readTrustManagers(): Array[TrustManager] =
+    config
+      .getOptional[String]("play.server.https.trustStore.path")
       .map { trustStorePath ⇒
-        val keyStoreType = config.getOptional[String]("play.server.https.keyStore.type").getOrElse(KeyStore.getDefaultType)
+        val keyStoreType       = config.getOptional[String]("play.server.https.keyStore.type").getOrElse(KeyStore.getDefaultType)
         val trustStorePassword = config.getOptional[String]("play.server.https.trustStore.password").getOrElse("").toCharArray
-        val trustInputStream = Files.newInputStream(Paths.get(trustStorePath))
+        val trustInputStream   = Files.newInputStream(Paths.get(trustStorePath))
         try {
           val keyStore = KeyStore.getInstance(keyStoreType)
           keyStore.load(trustInputStream, trustStorePassword)
           val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm)
           tmf.init(keyStore)
           tmf.getTrustManagers
-        }
-        finally {
+        } finally {
           trustInputStream.close()
         }
       }
       .getOrElse(Array.empty)
-  }
 
   def createSSLContext(applicationProvider: ApplicationProvider): SSLContext = {
-    val keyManagers = readKeyManagers()
+    val keyManagers   = readKeyManagers()
     val trustManagers = readTrustManagers()
 
     // Configure the SSL context to use TLS

diff --git a/app/org/elastic4play/ErrorHandler.scala b/app/org/elastic4play/ErrorHandler.scala
@@ -3,9 +3,9 @@ package org.elastic4play
 import scala.concurrent.Future
 
 import play.api.Logger
-import play.api.http.{ HttpErrorHandler, Status, Writeable }
-import play.api.libs.json.{ JsNull, JsValue, Json }
-import play.api.mvc.{ RequestHeader, ResponseHeader, Result, Results }
+import play.api.http.{HttpErrorHandler, Status, Writeable}
+import play.api.libs.json.{JsNull, JsValue, Json}
+import play.api.mvc.{RequestHeader, ResponseHeader, Result, Results}
 
 import org.elasticsearch.client.transport.NoNodeAvailableException
 import org.elasticsearch.index.IndexNotFoundException
@@ -24,22 +24,26 @@ class ErrorHandler extends HttpErrorHandler {
     Results.Status(statusCode)(s"A client error occurred on ${request.method} ${request.uri} : $message")
   }
 
-  def toErrorResult(ex: Throwable): Option[(Int, JsValue)] = {
+  def toErrorResult(ex: Throwable): Option[(Int, JsValue)] =
     ex match {
-      case AuthenticationError(message)        ⇒ Some(Status.UNAUTHORIZED → Json.obj("type" → "AuthenticationError", "message" → message))
-      case AuthorizationError(message)         ⇒ Some(Status.FORBIDDEN → Json.obj("type" → "AuthorizationError", "message" → message))
-      case UpdateError(_, message, attributes) ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "UpdateError", "message" → message, "object" → attributes))
-      case InternalError(message)              ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "InternalError", "message" → message))
-      case nfe: NumberFormatException          ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "NumberFormatException", "message" → ("Invalid format " + nfe.getMessage)))
-      case NotFoundError(message)              ⇒ Some(Status.NOT_FOUND → Json.obj("type" → "NotFoundError", "message" → message))
-      case BadRequestError(message)            ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "BadRequest", "message" → message))
-      case SearchError(message, cause)         ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "SearchError", "message" → s"$message (${cause.getMessage})"))
-      case ace: AttributeCheckingError         ⇒ Some(Status.BAD_REQUEST → Json.toJson(ace))
-      case iae: IllegalArgumentException       ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "IllegalArgument", "message" → iae.getMessage))
-      case _: NoNodeAvailableException         ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "NoNodeAvailable", "message" → "ElasticSearch cluster is unreachable"))
-      case CreateError(_, message, attributes) ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "CreateError", "message" → message, "object" → attributes))
-      case ErrorWithObject(tpe, message, obj)  ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → tpe, "message" → message, "object" → obj))
-      case GetError(message)                   ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "GetError", "message" → message))
+      case AuthenticationError(message) ⇒ Some(Status.UNAUTHORIZED → Json.obj("type" → "AuthenticationError", "message" → message))
+      case AuthorizationError(message)  ⇒ Some(Status.FORBIDDEN    → Json.obj("type" → "AuthorizationError", "message"  → message))
+      case UpdateError(_, message, attributes) ⇒
+        Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "UpdateError", "message" → message, "object" → attributes))
+      case InternalError(message) ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "InternalError", "message" → message))
+      case nfe: NumberFormatException ⇒
+        Some(Status.BAD_REQUEST → Json.obj("type" → "NumberFormatException", "message" → ("Invalid format " + nfe.getMessage)))
+      case NotFoundError(message)        ⇒ Some(Status.NOT_FOUND   → Json.obj("type" → "NotFoundError", "message" → message))
+      case BadRequestError(message)      ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "BadRequest", "message" → message))
+      case SearchError(message, cause)   ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "SearchError", "message" → s"$message (${cause.getMessage})"))
+      case ace: AttributeCheckingError   ⇒ Some(Status.BAD_REQUEST → Json.toJson(ace))
+      case iae: IllegalArgumentException ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "IllegalArgument", "message" → iae.getMessage))
+      case _: NoNodeAvailableException ⇒
+        Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "NoNodeAvailable", "message" → "ElasticSearch cluster is unreachable"))
+      case CreateError(_, message, attributes) ⇒
+        Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "CreateError", "message" → message, "object" → attributes))
+      case ErrorWithObject(tpe, message, obj) ⇒ Some(Status.BAD_REQUEST           → Json.obj("type" → tpe, "message"        → message, "object" → obj))
+      case GetError(message)                  ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "GetError", "message" → message))
       case MultiError(message, exceptions) ⇒
         val suberrors = exceptions.map(e ⇒ toErrorResult(e)).collect {
           case Some((_, j)) ⇒ j
@@ -49,13 +53,14 @@ class ErrorHandler extends HttpErrorHandler {
       case qse: QueryShardException  ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "Invalid search query", "message" → qse.getMessage))
       case t: Throwable              ⇒ Option(t.getCause).flatMap(toErrorResult)
     }
-  }
 
   def toResult[C](status: Int, c: C)(implicit writeable: Writeable[C]) = Result(header = ResponseHeader(status), body = writeable.toEntity(c))
 
   def onServerError(request: RequestHeader, exception: Throwable): Future[Result] = {
-    val (status, body) = toErrorResult(exception).getOrElse(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → exception.getClass.getName, "message" → exception.getMessage))
+    val (status, body) = toErrorResult(exception).getOrElse(
+      Status.INTERNAL_SERVER_ERROR → Json.obj("type" → exception.getClass.getName, "message" → exception.getMessage)
+    )
     logger.info(s"${request.method} ${request.uri} returned $status", exception)
     Future.successful(toResult(status, body))
   }
-}
+}
diff --git a/app/org/elastic4play/Errors.scala b/app/org/elastic4play/Errors.scala
@@ -1,31 +1,30 @@
 package org.elastic4play
 
-import play.api.libs.json.{ JsObject, JsValue }
+import play.api.libs.json.{JsObject, JsValue}
 
 import org.elastic4play.controllers.InputValue
 
 class ErrorWithObject(message: String, val obj: JsObject) extends Exception(message)
+
 object ErrorWithObject {
   def unapply(ewo: ErrorWithObject): Option[(String, String, JsObject)] = Some((ewo.getClass.getSimpleName, ewo.getMessage, ewo.obj))
 }
 
-case class BadRequestError(message: String) extends Exception(message)
+case class BadRequestError(message: String)                                           extends Exception(message)
 case class CreateError(status: Option[String], message: String, attributes: JsObject) extends ErrorWithObject(message, attributes)
-case class ConflictError(message: String, attributes: JsObject) extends ErrorWithObject(message, attributes)
-case class NotFoundError(message: String) extends Exception(message)
-case class GetError(message: String) extends Exception(message)
+case class ConflictError(message: String, attributes: JsObject)                       extends ErrorWithObject(message, attributes)
+case class NotFoundError(message: String)                                             extends Exception(message)
+case class GetError(message: String)                                                  extends Exception(message)
 case class UpdateError(status: Option[String], message: String, attributes: JsObject) extends ErrorWithObject(message, attributes)
-case class InternalError(message: String) extends Exception(message)
-case class SearchError(message: String, cause: Throwable) extends Exception(message, cause)
-case class AuthenticationError(message: String) extends Exception(message)
-case class OAuth2Redirect(redirectUrl: String, params: Map[String, Seq[String]]) extends Exception(redirectUrl)
-case class AuthorizationError(message: String) extends Exception(message)
-case class MultiError(message: String, exceptions: Seq[Exception]) extends Exception(message + exceptions.map(_.getMessage).mkString(" :\n\t- ", "\n\t- ", ""))
-
-case class AttributeCheckingError(
-    tableName: String,
-    errors: Seq[AttributeError] = Nil)
-  extends Exception(errors.mkString("[", "][", "]")) {
+case class InternalError(message: String)                                             extends Exception(message)
+case class SearchError(message: String, cause: Throwable)                             extends Exception(message, cause)
+case class AuthenticationError(message: String)                                       extends Exception(message)
+case class OAuth2Redirect(redirectUrl: String, params: Map[String, Seq[String]])      extends Exception(redirectUrl)
+case class AuthorizationError(message: String)                                        extends Exception(message)
+case class MultiError(message: String, exceptions: Seq[Exception])
+    extends Exception(message + exceptions.map(_.getMessage).mkString(" :\n\t- ", "\n\t- ", ""))
+
+case class AttributeCheckingError(tableName: String, errors: Seq[AttributeError] = Nil) extends Exception(errors.mkString("[", "][", "]")) {
   override def toString: String = errors.mkString("[", "][", "]")
 }
 
@@ -36,18 +35,18 @@ sealed trait AttributeError extends Throwable {
 }
 
 case class InvalidFormatAttributeError(name: String, format: String, value: InputValue) extends AttributeError {
-  override def toString = s"Invalid format for $name: $value, expected $format"
+  override def toString                                  = s"Invalid format for $name: $value, expected $format"
   override def withName(newName: String): AttributeError = copy(name = newName)
 }
 case class UnknownAttributeError(name: String, value: JsValue) extends AttributeError {
-  override def toString = s"Unknown attribute $name: $value"
+  override def toString                                  = s"Unknown attribute $name: $value"
   override def withName(newName: String): AttributeError = copy(name = newName)
 }
 case class UpdateReadOnlyAttributeError(name: String) extends AttributeError {
-  override def toString = s"Attribute $name is read-only"
+  override def toString                                  = s"Attribute $name is read-only"
   override def withName(newName: String): AttributeError = copy(name = newName)
 }
 case class MissingAttributeError(name: String) extends AttributeError {
-  override def toString = s"Attribute $name is missing"
+  override def toString                                  = s"Attribute $name is missing"
   override def withName(newName: String): AttributeError = copy(name = newName)
-}
+}
diff --git a/app/org/elastic4play/JsonFormat.scala b/app/org/elastic4play/JsonFormat.scala
@@ -2,53 +2,54 @@ package org.elastic4play
 
 import java.util.Date
 
-import scala.util.{ Failure, Success, Try }
+import scala.util.{Failure, Success, Try}
 
 import play.api.libs.json._
 
 import org.elastic4play.controllers.JsonFormat.inputValueFormat
 
 object JsonFormat {
-  val datePattern = "yyyyMMdd'T'HHmmssZ"
-  private val dateReads: Reads[Date] = Reads.dateReads(datePattern).orElse(Reads.DefaultDateReads).orElse(Reads.LongReads.map(new Date(_)))
-  private val dateWrites: Writes[Date] = Writes[Date](d ⇒ JsNumber(d.getTime))
+  val datePattern                       = "yyyyMMdd'T'HHmmssZ"
+  private val dateReads: Reads[Date]    = Reads.dateReads(datePattern).orElse(Reads.DefaultDateReads).orElse(Reads.LongReads.map(new Date(_)))
+  private val dateWrites: Writes[Date]  = Writes[Date](d ⇒ JsNumber(d.getTime))
   implicit val dateFormat: Format[Date] = Format(dateReads, dateWrites)
 
   private val invalidFormatAttributeErrorWrites = Writes[InvalidFormatAttributeError] { ifae ⇒
     Json.writes[InvalidFormatAttributeError].writes(ifae) +
-      ("type" → JsString("InvalidFormatAttributeError")) +
+      ("type"    → JsString("InvalidFormatAttributeError")) +
       ("message" → JsString(ifae.toString))
   }
   private val unknownAttributeErrorWrites = Writes[UnknownAttributeError] { uae ⇒
     Json.writes[UnknownAttributeError].writes(uae) +
-      ("type" → JsString("UnknownAttributeError")) +
+      ("type"    → JsString("UnknownAttributeError")) +
       ("message" → JsString(uae.toString))
   }
   private val updateReadOnlyAttributeErrorWrites = Writes[UpdateReadOnlyAttributeError] { uroae ⇒
     Json.writes[UpdateReadOnlyAttributeError].writes(uroae) +
-      ("type" → JsString("UpdateReadOnlyAttributeError")) +
+      ("type"    → JsString("UpdateReadOnlyAttributeError")) +
       ("message" → JsString(uroae.toString))
   }
   private val missingAttributeErrorWrites = Writes[MissingAttributeError] { mae ⇒
     Json.writes[MissingAttributeError].writes(mae) +
-      ("type" → JsString("MissingAttributeError")) +
+      ("type"    → JsString("MissingAttributeError")) +
       ("message" → JsString(mae.toString))
   }
 
   implicit val attributeCheckingExceptionWrites: OWrites[AttributeCheckingError] = OWrites[AttributeCheckingError] { ace ⇒
     Json.obj(
       "tableName" → ace.tableName,
-      "type" → "AttributeCheckingError",
+      "type"      → "AttributeCheckingError",
       "errors" → JsArray(ace.errors.map {
         case e: InvalidFormatAttributeError  ⇒ invalidFormatAttributeErrorWrites.writes(e)
         case e: UnknownAttributeError        ⇒ unknownAttributeErrorWrites.writes(e)
         case e: UpdateReadOnlyAttributeError ⇒ updateReadOnlyAttributeErrorWrites.writes(e)
         case e: MissingAttributeError        ⇒ missingAttributeErrorWrites.writes(e)
-      }))
+      })
+    )
   }
 
   implicit def tryWrites[A](implicit aWrites: Writes[A]): Writes[Try[A]] = Writes[Try[A]] {
     case Success(a) ⇒ aWrites.writes(a)
     case Failure(t) ⇒ JsString(t.getMessage)
   }
-}
+}