#62: Uses new scalafmt as a code formatting and reformats all the cod…

…e accordingly.
scala-jsonapi · Jul 30, 2016 · 7304bee · 7304bee
1 parent 1291f1c
commit 7304bee
Show file tree

Hide file tree

Showing 15 changed files with 466 additions and 432 deletions.
diff --git a/.scalafmt b/.scalafmt
@@ -0,0 +1 @@
+--maxColumn 120
diff --git a/build.sbt b/build.sbt
@@ -1,9 +1,5 @@
 import scoverage.ScoverageSbtPlugin
 
-import scalariform.formatter.preferences._
-import com.typesafe.sbt.SbtScalariform.ScalariformKeys
-import com.typesafe.sbt.SbtScalariform.scalariformSettings
-
 organization := "org.zalando"
 
 name := "scala-jsonapi"
@@ -37,14 +33,7 @@ libraryDependencies ++= {
   )
 }
 
-scalariformSettings ++ Seq(
-  ScalariformKeys.preferences := ScalariformKeys.preferences.value
-    .setPreference(AlignSingleLineCaseStatements, true)
-    .setPreference(DoubleIndentClassDeclaration, true)
-    .setPreference(PreserveDanglingCloseParenthesis, true)
-    .setPreference(PreserveSpaceBeforeArguments, true)
-    .setPreference(RewriteArrowSymbols, true)
-)
+scalafmtConfig in ThisBuild := Some(file(".scalafmt"))
 
 ScoverageSbtPlugin.ScoverageKeys.coverageMinimum := 80
 

diff --git a/project/plugins.sbt b/project/plugins.sbt
@@ -8,4 +8,4 @@ addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1")
 
 addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")
 
-addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.3.0")
+addSbtPlugin("com.geirsson" % "sbt-scalafmt" % "0.2.11")
diff --git a/src/main/scala/org/zalando/jsonapi/json/akka/http/AkkaHttpJsonapiSupport.scala b/src/main/scala/org/zalando/jsonapi/json/akka/http/AkkaHttpJsonapiSupport.scala
@@ -7,18 +7,22 @@ import akka.http.scaladsl.unmarshalling._
 import org.zalando.jsonapi.json.sprayjson.SprayJsonJsonapiProtocol
 import org.zalando.jsonapi.model._
 import org.zalando.jsonapi._
-import org.zalando.jsonapi.{ JsonapiRootObjectReader, JsonapiRootObjectWriter }
+import org.zalando.jsonapi.{JsonapiRootObjectReader, JsonapiRootObjectWriter}
 import spray.json._
 
 trait AkkaHttpJsonapiSupport extends SprayJsonJsonapiProtocol with DefaultJsonProtocol {
   def akkaHttpJsonapiMarshaller[T: JsonapiRootObjectWriter]: ToEntityMarshaller[T] =
     Marshaller.StringMarshaller.wrap(`application/vnd.api+json`)(_.rootObject.toJson.compactPrint)
 
   def akkaHttpJsonapiUnmarshaller[T: JsonapiRootObjectReader]: FromEntityUnmarshaller[T] =
-    Unmarshaller.stringUnmarshaller.forContentTypes(`application/vnd.api+json`).map(_.parseJson.convertTo[RootObject].jsonapi[T])
+    Unmarshaller.stringUnmarshaller
+      .forContentTypes(`application/vnd.api+json`)
+      .map(_.parseJson.convertTo[RootObject].jsonapi[T])
 }
 
 object AkkaHttpJsonapiSupport extends AkkaHttpJsonapiSupport {
-  implicit def akkaHttpJsonapiMarshallerImplicit[T: JsonapiRootObjectWriter]: ToEntityMarshaller[T] = akkaHttpJsonapiMarshaller
-  implicit def akkaHttpJsonapiUnmarshallerImplicit[T: JsonapiRootObjectReader]: FromEntityUnmarshaller[T] = akkaHttpJsonapiUnmarshaller
-}
+  implicit def akkaHttpJsonapiMarshallerImplicit[T: JsonapiRootObjectWriter]: ToEntityMarshaller[T] =
+    akkaHttpJsonapiMarshaller
+  implicit def akkaHttpJsonapiUnmarshallerImplicit[T: JsonapiRootObjectReader]: FromEntityUnmarshaller[T] =
+    akkaHttpJsonapiUnmarshaller
+}
diff --git a/src/main/scala/org/zalando/jsonapi/json/circe/CirceJsonapiDecoders.scala b/src/main/scala/org/zalando/jsonapi/json/circe/CirceJsonapiDecoders.scala
@@ -5,18 +5,19 @@ import io.circe._
 import org.zalando.jsonapi.json.FieldNames
 import org.zalando.jsonapi.model.JsonApiObject._
 import org.zalando.jsonapi.model.RootObject._
-import org.zalando.jsonapi.model.{ Errors, Error, _ }
+import org.zalando.jsonapi.model.{Errors, Error, _}
 
 trait CirceJsonapiDecoders {
   def jsonToValue(json: Json): Value = json.fold[Value](
-    NullValue,
-    BooleanValue.apply,
-    value ⇒ NumberValue(value.toBigDecimal.get),
-    StringValue.apply,
-    values ⇒ JsArrayValue(values.map(jsonToValue)),
-    values ⇒ JsObjectValue(values.toMap.map {
-      case (key, value) ⇒ Attribute(key, jsonToValue(value))
-    }.toList)
+      NullValue,
+      BooleanValue.apply,
+      value ⇒ NumberValue(value.toBigDecimal.get),
+      StringValue.apply,
+      values ⇒ JsArrayValue(values.map(jsonToValue)),
+      values ⇒
+        JsObjectValue(values.toMap.map {
+          case (key, value) ⇒ Attribute(key, jsonToValue(value))
+        }.toList)
   )
 
   implicit val valueDecoder = Decoder.instance[Value](_.as[Json].map(jsonToValue))
@@ -36,13 +37,16 @@ trait CirceJsonapiDecoders {
     hcursor.as[Value].flatMap {
       case JsObjectValue(attributes) ⇒
         Xor.Right(attributes.map {
-          case Attribute(FieldNames.`self`, StringValue(url))    ⇒ Links.Self(url)
-          case Attribute(FieldNames.`about`, StringValue(url))   ⇒ Links.About(url)
-          case Attribute(FieldNames.`first`, StringValue(url))   ⇒ Links.First(url)
-          case Attribute(FieldNames.`last`, StringValue(url))    ⇒ Links.Last(url)
-          case Attribute(FieldNames.`next`, StringValue(url))    ⇒ Links.Next(url)
-          case Attribute(FieldNames.`prev`, StringValue(url))    ⇒ Links.Prev(url)
-          case Attribute(FieldNames.`related`, StringValue(url)) ⇒ Links.Related(url)
+          case Attribute(FieldNames.`self`, StringValue(url)) ⇒ Links.Self(url)
+          case Attribute(FieldNames.`about`, StringValue(url)) ⇒
+            Links.About(url)
+          case Attribute(FieldNames.`first`, StringValue(url)) ⇒
+            Links.First(url)
+          case Attribute(FieldNames.`last`, StringValue(url)) ⇒ Links.Last(url)
+          case Attribute(FieldNames.`next`, StringValue(url)) ⇒ Links.Next(url)
+          case Attribute(FieldNames.`prev`, StringValue(url)) ⇒ Links.Prev(url)
+          case Attribute(FieldNames.`related`, StringValue(url)) ⇒
+            Links.Related(url)
         })
       case _ ⇒
         Xor.Left(DecodingFailure("only an object can be decoded to Links", hcursor.history))
@@ -61,10 +65,11 @@ trait CirceJsonapiDecoders {
       links ← hcursor.downField(FieldNames.`links`).as[Option[Links]]
       // TODO: there's prolly a cleaner way here. there's a circular dependency Data -> ResourceObject(s) -> Relationship(s) -> Data that's giving circe problems
       data ← hcursor.downField(FieldNames.`data`).as[Option[Json]].map(_.flatMap(jsonToData(_).toOption))
-    } yield Relationship(
-      links = links,
-      data = data
-    )
+    } yield
+      Relationship(
+          links = links,
+          data = data
+      )
   })
 
   implicit val relationshipsDecoder = Decoder.instance[Relationships](_.as[Map[String, Relationship]])
@@ -95,10 +100,11 @@ trait CirceJsonapiDecoders {
     for {
       pointer ← hcursor.downField(FieldNames.`pointer`).as[Option[String]]
       parameter ← hcursor.downField(FieldNames.`parameter`).as[Option[String]]
-    } yield ErrorSource(
-      pointer = pointer,
-      parameter = parameter
-    )
+    } yield
+      ErrorSource(
+          pointer = pointer,
+          parameter = parameter
+      )
   })
 
   implicit val errorDecoder = Decoder.instance[Error](hcursor ⇒ {
@@ -111,16 +117,17 @@ trait CirceJsonapiDecoders {
       links ← hcursor.downField(FieldNames.`links`).as[Option[Links]]
       meta ← hcursor.downField(FieldNames.`meta`).as[Option[Meta]]
       source ← hcursor.downField(FieldNames.`source`).as[Option[ErrorSource]]
-    } yield Error(
-      id = id,
-      status = status,
-      code = code,
-      title = title,
-      detail = detail,
-      links = links,
-      meta = meta,
-      source = source
-    )
+    } yield
+      Error(
+          id = id,
+          status = status,
+          code = code,
+          title = title,
+          detail = detail,
+          links = links,
+          meta = meta,
+          source = source
+      )
   })
 
   implicit val resourceObjectDecoder = Decoder.instance[ResourceObject](hcursor ⇒ {
@@ -131,17 +138,19 @@ trait CirceJsonapiDecoders {
       relationships ← hcursor.downField(FieldNames.`relationships`).as[Option[Relationships]]
       links ← hcursor.downField(FieldNames.`links`).as[Option[Links]]
       meta ← hcursor.downField(FieldNames.`meta`).as[Option[Meta]]
-    } yield ResourceObject(
-      id = id,
-      `type` = `type`,
-      attributes = attributes,
-      relationships = relationships,
-      links = links,
-      meta = meta
-    )
+    } yield
+      ResourceObject(
+          id = id,
+          `type` = `type`,
+          attributes = attributes,
+          relationships = relationships,
+          links = links,
+          meta = meta
+      )
   })
 
-  implicit val resourceObjectsDecoder = Decoder.instance[ResourceObjects](_.as[List[ResourceObject]].map(ResourceObjects))
+  implicit val resourceObjectsDecoder =
+    Decoder.instance[ResourceObjects](_.as[List[ResourceObject]].map(ResourceObjects))
 
   implicit val dataDecoder = Decoder.instance[Data](_.as[Json].flatMap(jsonToData))
 
@@ -155,14 +164,15 @@ trait CirceJsonapiDecoders {
       meta ← hcursor.downField(FieldNames.`meta`).as[Option[Meta]]
       included ← hcursor.downField(FieldNames.`included`).as[Option[Included]]
       jsonapi ← hcursor.downField(FieldNames.`jsonapi`).as[Option[JsonApi]]
-    } yield RootObject(
-      data = data,
-      links = links,
-      errors = errors,
-      meta = meta,
-      included = included,
-      jsonApi = jsonapi
-    )
+    } yield
+      RootObject(
+          data = data,
+          links = links,
+          errors = errors,
+          meta = meta,
+          included = included,
+          jsonApi = jsonapi
+      )
   })
 }
 

diff --git a/src/main/scala/org/zalando/jsonapi/json/circe/CirceJsonapiEncoders.scala b/src/main/scala/org/zalando/jsonapi/json/circe/CirceJsonapiEncoders.scala
@@ -37,13 +37,12 @@ trait CirceJsonapiEncoders {
 
   implicit def valueEncoder[V <: Value] = Encoder.instance[V](valueToJson)
 
-
   implicit val attributeEncoder = Encoder.instance[Attribute] {
     case Attribute(name, value) =>
       Json.fromFields(Seq(name -> value.asJson))
   }
   implicit val attributesEncoder = Encoder.instance[Attributes] {
-    case Seq(attributes@_*) =>
+    case Seq(attributes @ _ *) =>
       attributes.map(_.asJson).reduce(_.deepMerge(_))
   }
 
@@ -73,18 +72,19 @@ trait CirceJsonapiEncoders {
 
   lazy implicit val relationshipEncoder = Encoder.instance[Relationship](relationship => {
     jsonFromOptionalFields(
-      FieldNames.`links` -> relationship.links.map(_.asJson),
-      // TODO: there's prolly a cleaner way here. there's a circular dependency Data -> ResourceObject(s) -> Relationship(s) -> Data that's giving circe problems
-      FieldNames.`data` -> relationship.data.map(dataToJson) 
+        FieldNames.`links` -> relationship.links.map(_.asJson),
+        // TODO: there's prolly a cleaner way here. there's a circular dependency Data -> ResourceObject(s) -> Relationship(s) -> Data that's giving circe problems
+        FieldNames.`data` -> relationship.data.map(dataToJson)
     )
   })
 
-  implicit val relationshipsEncoder = Encoder.instance[Relationships](relationships => Json.fromFields(relationships.map {
-    case (name, value) => name -> value.asJson
-  }))
+  implicit val relationshipsEncoder = Encoder.instance[Relationships](relationships =>
+        Json.fromFields(relationships.map {
+      case (name, value) => name -> value.asJson
+    }))
 
   implicit val jsonApiEncoder = Encoder.instance[JsonApi] {
-    case Seq(jsonApiPropertys@_*) =>
+    case Seq(jsonApiPropertys @ _ *) =>
       Json.fromFields(jsonApiPropertys.map {
         case JsonApiProperty(name, value) =>
           name -> value.asJson
@@ -99,32 +99,32 @@ trait CirceJsonapiEncoders {
 
   implicit val errorSourceEncoder = Encoder.instance[ErrorSource](errorSource => {
     jsonFromOptionalFields(
-      FieldNames.`pointer` -> errorSource.pointer.map(Json.fromString),
-      FieldNames.`parameter` -> errorSource.parameter.map(Json.fromString)
+        FieldNames.`pointer` -> errorSource.pointer.map(Json.fromString),
+        FieldNames.`parameter` -> errorSource.parameter.map(Json.fromString)
     )
   })
 
   implicit val errorEncoder = Encoder.instance[Error](error => {
     jsonFromOptionalFields(
-      FieldNames.`id` -> error.id.map(Json.fromString),
-      FieldNames.`status` -> error.status.map(Json.fromString),
-      FieldNames.`code` -> error.code.map(Json.fromString),
-      FieldNames.`title` -> error.title.map(Json.fromString),
-      FieldNames.`detail` -> error.detail.map(Json.fromString),
-      FieldNames.`links` -> error.links.map(_.asJson),
-      FieldNames.`meta` -> error.meta.map(_.asJson),
-      FieldNames.`source` -> error.source.map(_.asJson)
+        FieldNames.`id` -> error.id.map(Json.fromString),
+        FieldNames.`status` -> error.status.map(Json.fromString),
+        FieldNames.`code` -> error.code.map(Json.fromString),
+        FieldNames.`title` -> error.title.map(Json.fromString),
+        FieldNames.`detail` -> error.detail.map(Json.fromString),
+        FieldNames.`links` -> error.links.map(_.asJson),
+        FieldNames.`meta` -> error.meta.map(_.asJson),
+        FieldNames.`source` -> error.source.map(_.asJson)
     )
   })
 
   implicit val resourceObjectEncoder = Encoder.instance[ResourceObject](resourceObject => {
     jsonFromOptionalFields(
-      FieldNames.`type` -> Option(Json.fromString(resourceObject.`type`)),
-      FieldNames.`id` -> resourceObject.id.map(Json.fromString),
-      FieldNames.`attributes` -> resourceObject.attributes.map(_.asJson),
-      FieldNames.`relationships` -> resourceObject.relationships.map(_.asJson),
-      FieldNames.`links` -> resourceObject.links.map(_.asJson),
-      FieldNames.`meta` -> resourceObject.meta.map(_.asJson)
+        FieldNames.`type` -> Option(Json.fromString(resourceObject.`type`)),
+        FieldNames.`id` -> resourceObject.id.map(Json.fromString),
+        FieldNames.`attributes` -> resourceObject.attributes.map(_.asJson),
+        FieldNames.`relationships` -> resourceObject.relationships.map(_.asJson),
+        FieldNames.`links` -> resourceObject.links.map(_.asJson),
+        FieldNames.`meta` -> resourceObject.meta.map(_.asJson)
     )
   })
 
@@ -139,12 +139,12 @@ trait CirceJsonapiEncoders {
 
   implicit val rootObjectEncoder = Encoder.instance[RootObject](rootObject => {
     jsonFromOptionalFields(
-      FieldNames.`data` -> rootObject.data.map(_.asJson),
-      FieldNames.`links` -> rootObject.links.map(_.asJson),
-      FieldNames.`errors` -> rootObject.errors.map(_.asJson),
-      FieldNames.`meta` -> rootObject.meta.map(_.asJson),
-      FieldNames.`included` -> rootObject.included.map(_.asJson),
-      FieldNames.`jsonapi` -> rootObject.jsonApi.map(_.asJson)
+        FieldNames.`data` -> rootObject.data.map(_.asJson),
+        FieldNames.`links` -> rootObject.links.map(_.asJson),
+        FieldNames.`errors` -> rootObject.errors.map(_.asJson),
+        FieldNames.`meta` -> rootObject.meta.map(_.asJson),
+        FieldNames.`included` -> rootObject.included.map(_.asJson),
+        FieldNames.`jsonapi` -> rootObject.jsonApi.map(_.asJson)
     )
   })
 }

diff --git a/src/main/scala/org/zalando/jsonapi/json/circe/CirceJsonapiSupport.scala b/src/main/scala/org/zalando/jsonapi/json/circe/CirceJsonapiSupport.scala
@@ -11,13 +11,13 @@ import spray.httpx.unmarshalling.Unmarshaller
 
 trait CirceJsonapiSupport extends CirceJsonapiEncoders with CirceJsonapiDecoders {
   implicit val circeJsonapiMarshaller = Marshaller.delegate[RootObject, String](
-    `application/vnd.api+json`,
-    `application/json`,
-    ContentTypes.`application/json`
+      `application/vnd.api+json`,
+      `application/json`,
+      ContentTypes.`application/json`
   )(_.asJson.noSpaces)
   implicit val circeJsonapiUnmarshaller = Unmarshaller.delegate[String, RootObject](
-    `application/vnd.api+json`,
-    `application/json`
+      `application/vnd.api+json`,
+      `application/json`
   )(decode[RootObject](_).toOption.get)
 }