scalafmt

Author: Leif Battermann

.scalafmt.conf

@@ -0,0 +1,6 @@
+style = defaultWithAlign
+maxColumn = 160
+newlines.penalizeSingleSelectMultiArgList = false
+project.excludeFilters = [
+  target/
+]

project/plugins.sbt

@@ -1,4 +1,5 @@
 addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "2.3")
 addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.0")
 addSbtPlugin("org.lyranthe.sbt" % "partial-unification" % "1.1.0")
-addSbtPlugin("io.get-coursier" % "sbt-coursier" % "1.0.1")
+addSbtPlugin("io.get-coursier" % "sbt-coursier" % "1.0.1")
+addSbtPlugin("com.lucidchart" % "sbt-scalafmt" % "1.15")

src/main/scala/json2caseclass/CaseClassGenerator.scala

@@ -9,17 +9,16 @@ import json2caseclass.model.Types._
 
 object CaseClassGenerator {
 
-  def generate(conf: Config)(
-      jsonString: JsonString,
-      rootTypeName: RootTypeName,
-      optionals: Seq[(ClassName, ClassFieldName)] = Nil): Either[CaseClassGenerationFailure, CaseClassSource] = {
+  def generate(conf: Config)(jsonString: JsonString,
+                             rootTypeName: RootTypeName,
+                             optionals: Seq[(ClassName, ClassFieldName)] = Nil): Either[CaseClassGenerationFailure, CaseClassSource] = {
 
     val generate = for {
-      jsValue <- ? <~ JsonParser.parse(jsonString)
-      schema <- SchemaExtractor.extractSchemaFromJsonRoot(rootTypeName, jsValue)
+      jsValue     <- ? <~ JsonParser.parse(jsonString)
+      schema      <- SchemaExtractor.extractSchemaFromJsonRoot(rootTypeName, jsValue)
       caseClasses <- ? <~ SchemaToCaseClassConverter.convert(schema)
-      renamed = CaseClassOperations.renameAmbiguous(makeUnique, caseClasses)
-      withOptionals = CaseClassOperations.addOptionals(renamed, optionals)
+      renamed         = CaseClassOperations.renameAmbiguous(makeUnique, caseClasses)
+      withOptionals   = CaseClassOperations.addOptionals(renamed, optionals)
       caseClassSource = conf.interpreter(withOptionals)
     } yield caseClassSource
 

src/main/scala/json2caseclass/implementation/CaseClassNameGenerator.scala

@@ -4,9 +4,10 @@ import json2caseclass.model.CaseClass._
 
 object CaseClassNameGenerator {
   def makeUnique(takenClassNames: Set[String], name: ClassName): Option[ClassName] = {
-    val suffixes = "" #:: Stream.from(1).map(_.toString)
+    val suffixes        = "" #:: Stream.from(1).map(_.toString)
     val namesWithSuffix = suffixes.map(suffix => s"$name$suffix")
-    namesWithSuffix.find(nameWithSuffix => !takenClassNames.contains(nameWithSuffix))
+    namesWithSuffix
+      .find(nameWithSuffix => !takenClassNames.contains(nameWithSuffix))
       .map(_.toClassName)
   }
 }

src/main/scala/json2caseclass/implementation/CaseClassOperations.scala

@@ -13,24 +13,20 @@ object CaseClassOperations {
   }
 
   def addOptionals(caseClasses: Seq[CaseClass], optionals: Seq[(ClassName, ClassFieldName)]): Seq[CaseClass] = {
-    caseClasses.map { case o@CaseClass(_, name, fields) =>
-      val withOptionals =
-        fields.map {
-          case (fName, scalaType) if optionals.contains(name -> fName) =>
-            (fName, ScalaOption(scalaType))
-          case other => other
-        }
-      o.copy(fields = withOptionals)
+    caseClasses.map {
+      case o @ CaseClass(_, name, fields) =>
+        val withOptionals =
+          fields.map {
+            case (fName, scalaType) if optionals.contains(name -> fName) =>
+              (fName, ScalaOption(scalaType))
+            case other => other
+          }
+        o.copy(fields = withOptionals)
     }
   }
 
-  private def findAlternativeNames(
-    makeUnique: (Set[String], ClassName) => Option[ClassName],
-    caseClasses: Seq[CaseClass]): Map[Int, ClassName] = {
-    def alternativeNamesRec(
-      ccs: Seq[CaseClass],
-      alreadyTakenNames: Set[String],
-      acc: Map[Int, ClassName]): Map[Int, ClassName] = {
+  private def findAlternativeNames(makeUnique: (Set[String], ClassName) => Option[ClassName], caseClasses: Seq[CaseClass]): Map[Int, ClassName] = {
+    def alternativeNamesRec(ccs: Seq[CaseClass], alreadyTakenNames: Set[String], acc: Map[Int, ClassName]): Map[Int, ClassName] = {
 
       ccs match {
         case Nil => acc
@@ -50,7 +46,7 @@ object CaseClassOperations {
   private def rename(caseClasses: Seq[CaseClass], alternativeNames: Map[Int, ClassName]): Seq[CaseClass] = {
     def renameFieldTypes(fields: Seq[(ClassFieldName, ScalaType)]) = {
       fields.map {
-        case f@(fName, ScalaObject(id, _)) =>
+        case f @ (fName, ScalaObject(id, _)) =>
           alternativeNames
             .get(id)
             .map(altName => (fName, ScalaObject(id, altName.toScalaObjectName)))
@@ -59,12 +55,13 @@ object CaseClassOperations {
       }
     }
 
-    caseClasses.map { case o@CaseClass(id, _, fields) =>
-      alternativeNames
-        .get(id)
-        .map(altName => o.copy(name = altName))
-        .getOrElse(o)
-        .copy(fields = renameFieldTypes(fields))
+    caseClasses.map {
+      case o @ CaseClass(id, _, fields) =>
+        alternativeNames
+          .get(id)
+          .map(altName => o.copy(name = altName))
+          .getOrElse(o)
+          .copy(fields = renameFieldTypes(fields))
     }
   }
 }

src/main/scala/json2caseclass/implementation/CaseClassToStringInterpreter.scala

@@ -7,22 +7,20 @@ import json2caseclass.model.{ScalaType, _}
 object CaseClassToStringInterpreter {
 
   implicit class InterpreterOptions(interpreter: Interpreter) {
-    def withPlayJsonFormats = CaseClassToStringInterpreter.withPlayJsonFormats(interpreter)
+    def withPlayJsonFormats =
+      CaseClassToStringInterpreter.withPlayJsonFormats(interpreter)
   }
 
-  def withPlayJsonFormats: Interpreter => Interpreter = {
-    interpreter => {
-      caseClasses =>
-        s"""${interpreter(caseClasses)}
+  def withPlayJsonFormats: Interpreter => Interpreter = { interpreter =>
+    { caseClasses =>
+      s"""${interpreter(caseClasses)}
            |${createCompanionObjectWithPlayJsonFormats(caseClasses)}
-           |"""
-          .stripMargin
-          .toCaseClassSource
+           |""".stripMargin.toCaseClassSource
     }
   }
 
-  def plainCaseClasses: Interpreter = {
-    caseClasses => {
+  def plainCaseClasses: Interpreter = { caseClasses =>
+    {
       val caseClassSource = caseClasses
         .map(interpret)
         .mkString("\n\n") + "\n"
@@ -51,7 +49,7 @@ object CaseClassToStringInterpreter {
     val CaseClass(_, _, fields) = caseClass
 
     fields.forall {
-      case o@(_, ScalaObject(_, _)) =>
+      case o @ (_, ScalaObject(_, _)) =>
         typeExistsInUnresolvedDeps(alreadyDefined, o._2)
       case (_, ScalaSeq(t)) =>
         typeExistsInUnresolvedDeps(alreadyDefined, t)
@@ -75,7 +73,6 @@ object CaseClassToStringInterpreter {
     }
   }
 
-
   private def createCompanionObjectWithPlayJsonFormats(caseClasses: Seq[CaseClass]): String = {
     val formats =
       sortForPlayJsonFormats(caseClasses)
@@ -92,8 +89,9 @@ object CaseClassToStringInterpreter {
   private def interpret(caseClass: CaseClass): String = {
     val CaseClass(_, name, fields) = caseClass
 
-    val members = fields.map { case (fieldName, fieldType) =>
-      s"$fieldName: ${typeName(fieldType)}"
+    val members = fields.map {
+      case (fieldName, fieldType) =>
+        s"$fieldName: ${typeName(fieldType)}"
     }
 
     s"case class $name(${members.map(m => s"\n  $m").mkString(",")}\n)"
@@ -102,12 +100,11 @@ object CaseClassToStringInterpreter {
   private def typeName(scalaType: ScalaType): String = {
     scalaType match {
       case ScalaOption(optionType) => s"Option[${typeName(optionType)}]"
-      case ScalaString => "String"
-      case ScalaDouble => "Double"
-      case ScalaBoolean => "Boolean"
-      case ScalaSeq(seqType) => s"Seq[${typeName(seqType)}]"
-      case ScalaObject(_, name) => name
+      case ScalaString             => "String"
+      case ScalaDouble             => "Double"
+      case ScalaBoolean            => "Boolean"
+      case ScalaSeq(seqType)       => s"Seq[${typeName(seqType)}]"
+      case ScalaObject(_, name)    => name
     }
   }
 }
-

src/main/scala/json2caseclass/implementation/NameTransformer.scala

@@ -13,7 +13,7 @@ object NameTransformer {
   )
 
   def makeSafeFieldName(fieldName: String): SchemaFieldName = {
-    if (reservedWords.contains(fieldName.toLowerCase)|| containsInvalidChars(fieldName)) {
+    if (reservedWords.contains(fieldName.toLowerCase) || containsInvalidChars(fieldName)) {
       s"`$fieldName`".toSchemaFieldName
     } else {
       fieldName.toSchemaFieldName
@@ -25,8 +25,9 @@ object NameTransformer {
   }
 
   def normalizeName(suffix: Suffix)(objectName: String): String = {
-    if (reservedWords.contains(objectName.toLowerCase) || scalaTypes.map(_.toLowerCase).contains(
-      objectName.toLowerCase)) {
+    if (reservedWords.contains(objectName.toLowerCase) || scalaTypes
+          .map(_.toLowerCase)
+          .contains(objectName.toLowerCase)) {
       s"${objectName.capitalize}$suffix"
     } else {
       objectName
@@ -39,7 +40,7 @@ object NameTransformer {
   }
 
   def containsInvalidChars(name: String): Boolean = {
-    val invalidChars = "[^a-zA-Z0-9_]"
+    val invalidChars     = "[^a-zA-Z0-9_]"
     val invalidFirstChar = "^[^a-zA-Z_]"
     Pattern.compile(invalidChars).matcher(name).find() ||
     Pattern.compile(invalidFirstChar).matcher(name).find()

src/main/scala/json2caseclass/implementation/SchemaExtractor.scala

@@ -3,20 +3,14 @@ package json2caseclass.implementation
 import cats.data.ReaderWriterStateT._
 import cats.implicits._
 import json2caseclass.model.Schema._
-import json2caseclass.model.Types.{
-  ErrorOr,
-  ErrorRWSOr,
-  JsValueFilter,
-  RootTypeName
-}
+import json2caseclass.model.Types.{ErrorOr, ErrorRWSOr, JsValueFilter, RootTypeName}
 import json2caseclass.model._
 import play.api.libs.json._
 import scala.language.existentials
 
 object SchemaExtractor {
 
-  def extractSchemaFromJsonRoot(rootTypeName: RootTypeName,
-                                value: JsValue): ErrorRWSOr[Schema] = {
+  def extractSchemaFromJsonRoot(rootTypeName: RootTypeName, value: JsValue): ErrorRWSOr[Schema] = {
     value match {
       case JsObject(fields) =>
         extractSchemaFromJsObjectFields(rootTypeName, fields.toList)
@@ -27,9 +21,7 @@ object SchemaExtractor {
     }
   }
 
-  private def extractSchemaFromJsObjectFields(
-      name: String,
-      fields: List[(String, JsValue)]): ErrorRWSOr[Schema] = {
+  private def extractSchemaFromJsObjectFields(name: String, fields: List[(String, JsValue)]): ErrorRWSOr[Schema] = {
     for {
       env <- ask[ErrorOr, Environment, Unit, Int]
       fieldSchemas <- fields
@@ -47,9 +39,7 @@ object SchemaExtractor {
     } yield schema
   }
 
-  private def extractSchemaFromJsValue(
-      name: String,
-      value: JsValue): ErrorRWSOr[(String, Schema)] = {
+  private def extractSchemaFromJsValue(name: String, value: JsValue): ErrorRWSOr[(String, Schema)] = {
     val schemaOrError = value match {
       case JsNull =>
         ? <~ Left(ValueIsNull(name))
@@ -74,9 +64,7 @@ object SchemaExtractor {
     }
   }
 
-  private def extractSchemaFromArray(
-      name: String,
-      values: List[JsValue]): ErrorRWSOr[Schema] = {
+  private def extractSchemaFromArray(name: String, values: List[JsValue]): ErrorRWSOr[Schema] = {
     for {
       env <- ask[ErrorOr, Environment, Unit, Int]
       schemas <- values
@@ -87,8 +75,7 @@ object SchemaExtractor {
       schemaErrorRWSOr = if (schemas forall (haveSameStructure(_, first))) {
         ? <~ Right(SchemaArray(first))
       } else if (schemas forall isObject) {
-        mkSchemaObject(env.nameTransformer.makeSafeCamelCaseClassName(name),
-                       unify(schemas))
+        mkSchemaObject(env.nameTransformer.makeSafeCamelCaseClassName(name), unify(schemas))
           .map(SchemaArray)
       } else {
         ? <~ Left(ArrayTypeNotConsistent(name))
@@ -97,11 +84,10 @@ object SchemaExtractor {
     } yield schema
   }
 
-  private def mkSchemaObject(name: SchemaObjectName,
-                             fields: Seq[(SchemaFieldName, Schema)]) = {
+  private def mkSchemaObject(name: SchemaObjectName, fields: Seq[(SchemaFieldName, Schema)]) = {
     for {
       id <- get[ErrorOr, Environment, Unit, Int]
-      _ <- modify[ErrorOr, Environment, Unit, Int]((_: Int) + 1)
+      _  <- modify[ErrorOr, Environment, Unit, Int]((_: Int) + 1)
     } yield
       SchemaObject(
         id,
@@ -114,8 +100,7 @@ object SchemaExtractor {
     def containsField(t: Schema, field: (String, Schema)) = {
       t match {
         case SchemaObject(_, _, xs) =>
-          xs.exists(x =>
-            x._1 == field._1 && Schema.haveSameStructure(x._2, field._2))
+          xs.exists(x => x._1 == field._1 && Schema.haveSameStructure(x._2, field._2))
         case _ => false
       }
     }
@@ -125,16 +110,12 @@ object SchemaExtractor {
       case _                          => Nil
     }
 
-    def filterDuplicates(list: List[(SchemaFieldName, Schema)])
-      : List[(SchemaFieldName, Schema)] = {
-      def filterRec(list: List[(SchemaFieldName, Schema)],
-                    acc: List[(SchemaFieldName, Schema)])
-        : List[(SchemaFieldName, Schema)] = {
+    def filterDuplicates(list: List[(SchemaFieldName, Schema)]): List[(SchemaFieldName, Schema)] = {
+      def filterRec(list: List[(SchemaFieldName, Schema)], acc: List[(SchemaFieldName, Schema)]): List[(SchemaFieldName, Schema)] = {
         list match {
           case Nil => acc
           case h :: t =>
-            if (acc.exists(
-                  x => x._1 == h._1 && Schema.haveSameStructure(x._2, h._2))) {
+            if (acc.exists(x => x._1 == h._1 && Schema.haveSameStructure(x._2, h._2))) {
               filterRec(t, acc)
             } else {
               filterRec(t, h :: acc)
@@ -146,8 +127,7 @@ object SchemaExtractor {
 
     val (required, optionals) =
       filterDuplicates(allFields)
-        .partition(field =>
-          schemas.forall(schema => containsField(schema, field)))
+        .partition(field => schemas.forall(schema => containsField(schema, field)))
 
     val combinedFields = required ++ optionals.map {
       case (n, s) => (n, SchemaOption(s))