scalafmt reformat (#91)

* scalafmt config

* scalafmt reformat

* revert scaladoc to javadoc

* danglingParentheses = true

* delete scalariform prefs

* delete scalariform imports

* disabling test

core/src/main/scala/fluence/codec/Codec.scala

@@ -51,7 +51,9 @@ object Codec {
   implicit def identityCodec[F[_]: Applicative, T]: Codec[F, T, T] =
     Codec(_.pure[F], _.pure[F])
 
-  implicit def traverseCodec[F[_] : Applicative, G[_] : Traverse, O, B](implicit codec: Codec[F, O, B]): Codec[F, G[O], G[B]] =
+  implicit def traverseCodec[F[_]: Applicative, G[_]: Traverse, O, B](
+    implicit codec: Codec[F, O, B]
+  ): Codec[F, G[O], G[B]] =
     Codec[F, G[O], G[B]](Traverse[G].traverse[F, O, B](_)(codec.encode), Traverse[G].traverse[F, B, O](_)(codec.decode))
 
   implicit def toDirect[F[_], A, B](implicit cod: Codec[F, A, B]): Kleisli[F, A, B] =
@@ -70,10 +72,11 @@ object Codec {
   implicit def byteVectorB64[F[_]](implicit F: ApplicativeError[F, Throwable]): Codec[F, String, ByteVector] =
     Codec(
       str ⇒
-        ByteVector.fromBase64(str).fold[F[ByteVector]](
+        ByteVector
+          .fromBase64(str)
+          .fold[F[ByteVector]](
             F.raiseError(new IllegalArgumentException(s"Given string is not valid b64: $str"))
           )(_.pure[F]),
-
       _.toBase64.pure[F]
     )
 

kryo/src/main/scala/fluence/codec/kryo/KryoCodecs.scala

@@ -43,7 +43,8 @@ class KryoCodecs[F[_], L <: HList] private (pool: KryoPool)(implicit F: MonadErr
    */
   implicit def codec[T](implicit sel: ops.hlist.Selector[L, T]): Codec[F, T, Array[Byte]] =
     Codec(
-      obj ⇒ Option(obj) match {
+      obj ⇒
+        Option(obj) match {
           case Some(o) ⇒
             F.catchNonFatal(Option(pool.toBytesWithClass(o))).flatMap {
               case Some(v) ⇒ F.pure(v)
@@ -51,7 +52,9 @@ class KryoCodecs[F[_], L <: HList] private (pool: KryoPool)(implicit F: MonadErr
             }
           case None ⇒
             F.raiseError[Array[Byte]](new NullPointerException("Obj is null, encoding is impossible"))
-      }, binary ⇒ F.catchNonFatal(pool.fromBytes(binary).asInstanceOf[T]))
+      },
+      binary ⇒ F.catchNonFatal(pool.fromBytes(binary).asInstanceOf[T])
+    )
 }
 
 object KryoCodecs {
@@ -62,6 +65,7 @@ object KryoCodecs {
    * @tparam L List of registered classes
    */
   class Builder[L <: HList] private[KryoCodecs] (klasses: Seq[Class[_]]) {
+
     /**
      * Register a new case class T to Kryo
      * @tparam T Type to add
@@ -70,7 +74,9 @@ object KryoCodecs {
      * @param sa Presence of all types of S inside L
      * @return Extended builder
      */
-    def addCase[T, S <: HList](klass: Class[T])(implicit gen: Generic.Aux[T, S], sa: ops.hlist.SelectAll[L, S]): Builder[T :: L] =
+    def addCase[T, S <: HList](
+      klass: Class[T]
+    )(implicit gen: Generic.Aux[T, S], sa: ops.hlist.SelectAll[L, S]): Builder[T :: L] =
       new Builder[T :: L](klasses :+ klass)
 
     /**
@@ -88,7 +94,9 @@ object KryoCodecs {
      * @tparam F Effect type
      * @return Configured instance of KryoCodecs
      */
-    def build[F[_]](poolSize: Int = Runtime.getRuntime.availableProcessors)(implicit F: MonadError[F, Throwable]): KryoCodecs[F, L] =
+    def build[F[_]](
+      poolSize: Int = Runtime.getRuntime.availableProcessors
+    )(implicit F: MonadError[F, Throwable]): KryoCodecs[F, L] =
       new KryoCodecs[F, L](
         KryoPool.withByteArrayOutputStream(
           poolSize,

kryo/src/main/scala/fluence/codec/kryo/KryoFactory.scala

@@ -26,7 +26,8 @@ import org.objenesis.strategy.StdInstantiatorStrategy
  * @param classesToReg additional classes for registration
  * @param registrationRequired if true, an exception is thrown when an unregistered class is encountered.
  */
-private[kryo] case class KryoFactory(classesToReg: Seq[Class[_]], registrationRequired: Boolean) extends KryoInstantiator {
+private[kryo] case class KryoFactory(classesToReg: Seq[Class[_]], registrationRequired: Boolean)
+    extends KryoInstantiator {
 
   override def newKryo(): KryoBase = {
     val kryo = new KryoBase()

kryo/src/test/scala/fluence/codec/kryo/KryoCodecsSpec.scala

@@ -30,7 +30,8 @@ class KryoCodecsSpec extends WordSpec with Matchers {
   private val testCodecs =
     KryoCodecs()
       .add[Array[Array[Byte]]]
-      .addCase(classOf[TestClass]).build[Try]()
+      .addCase(classOf[TestClass])
+      .build[Try]()
 
   "encode and decode" should {
     "be inverse functions" when {
@@ -69,4 +70,3 @@ class KryoCodecsSpec extends WordSpec with Matchers {
 }
 
 case class TestClass(str: String, num: Long, blob: Array[Array[Byte]])
-