Scalafmt the source

Author: JanBessai

.scalafmt.conf

@@ -0,0 +1,10 @@
+version = 3.9.4
+rewrite.rules = [ AvoidInfix, SortImports ]
+runner.dialect = scala36
+project {
+  git = true
+  excludeFilters = [
+    plugin/src/sbt-test
+  ]
+  layout = StandardConvention
+}

src/main/scala/org/combinators/templating/persistable/JavaPersistable.scala

@@ -26,25 +26,29 @@ import scala.collection.immutable._
 import scala.jdk.CollectionConverters._
 
 trait JavaPersistableInstances {
-  /** Persistable instance for a compilation unit.
-    * Derives path and file names from the package and the name of the first declared type.
+
+  /** Persistable instance for a compilation unit. Derives path and file names
+    * from the package and the name of the first declared type.
     */
   implicit def compilationUnitInstance: JavaPersistable.Aux[CompilationUnit] =
     new Persistable {
       type T = CompilationUnit
-      override def rawText(compilationUnit: CompilationUnit) = compilationUnit.toString.getBytes
+      override def rawText(compilationUnit: CompilationUnit) =
+        compilationUnit.toString.getBytes
       override def path(compilationUnit: CompilationUnit) = {
         val pkg: Seq[String] =
           compilationUnit.getPackageDeclaration.orElse(null) match {
             case null => Seq.empty
             case somePkg =>
-              somePkg.accept(new GenericVisitorAdapter[Seq[String], Unit] {
-                override def visit(name: NameExpr, arg: Unit): Seq[String] = Seq(name.getNameAsString)
-                override def visit(name: Name, arg: Unit): Seq[String] =
-                  Option(name.getQualifier.orElse(null))
-                    .map((q: Name) => q.accept(this, arg))
-                    .getOrElse(Seq.empty[String]) :+ name.getIdentifier
-              },
+              somePkg.accept(
+                new GenericVisitorAdapter[Seq[String], Unit] {
+                  override def visit(name: NameExpr, arg: Unit): Seq[String] =
+                    Seq(name.getNameAsString)
+                  override def visit(name: Name, arg: Unit): Seq[String] =
+                    Option(name.getQualifier.orElse(null))
+                      .map((q: Name) => q.accept(this, arg))
+                      .getOrElse(Seq.empty[String]) :+ name.getIdentifier
+                },
                 ()
               )
           }

src/main/scala/org/combinators/templating/persistable/Persistable.scala

@@ -21,24 +21,27 @@ import java.io.File
 
 /** Type class for persistable objects (inhabitants). */
 trait Persistable {
+
   /** The type of the object to persist */
   type T
+
   /** Serialized representation of the object */
   def rawText(elem: T): Array[Byte]
-  /** Path where to store the object `elem` (relative to some later specified root) */
+
+  /** Path where to store the object `elem` (relative to some later specified
+    * root)
+    */
   def path(elem: T): Path
 
-  /**
-    * Computes the full path where to place `elem` relative to `basePath`.
+  /** Computes the full path where to place `elem` relative to `basePath`.
     */
   def fullPath(basePath: Path, elem: T): Path = {
     basePath.resolve(path(elem))
   }
 
-
-  /**
-    * Persists this object to an object dependent path under `basePath` and returns the persisted file.
-    * Overwrites any pre-existing files under `basePath` / `path`.
+  /** Persists this object to an object dependent path under `basePath` and
+    * returns the persisted file. Overwrites any pre-existing files under
+    * `basePath` / `path`.
     */
   def persistOverwriting(basePath: Path, elem: T): File = {
     val fp = fullPath(basePath, elem)
@@ -48,9 +51,9 @@ trait Persistable {
     fp.toFile
   }
 
-  /**
-    * Persists this object to an object dependent path under `basePath` and returns the persisted file.
-    * Throws an `FileAlreadyExistsException` if the file already exists.
+  /** Persists this object to an object dependent path under `basePath` and
+    * returns the persisted file. Throws an `FileAlreadyExistsException` if the
+    * file already exists.
     */
   def persist(basePath: Path, elem: T): File = {
     val fp = fullPath(basePath, elem)
@@ -64,4 +67,4 @@ object Persistable {
   type Aux[TT] = Persistable { type T = TT }
 
   def apply[T](implicit persistable: Aux[T]): Aux[T] = persistable
-}
+}

src/main/scala/org/combinators/templating/persistable/PythonWithPathPersistable.scala

@@ -24,8 +24,10 @@ import org.combinators.templating.twirl.Python
 case class PythonWithPath(code: Python, persistTo: Path)
 
 trait PythonWithPathPersistableInstances {
+
   /** Persistable instance for [PythonWithPath]. */
-  implicit def pythonWithPathPersistable: PythonWithPathPersistable.Aux[PythonWithPath] = new Persistable {
+  implicit def pythonWithPathPersistable
+      : PythonWithPathPersistable.Aux[PythonWithPath] = new Persistable {
     type T = PythonWithPath
     def rawText(elem: PythonWithPath): Array[Byte] = elem.code.getCode.getBytes
     def path(elem: PythonWithPath): Path = elem.persistTo

src/main/scala/org/combinators/templating/persistable/ResourcePersistable.scala

@@ -20,18 +20,27 @@ import java.nio.file.{Files, Path, Paths}
 
 /** A persistable resource on the classpath.
   *
-  * @param name the name by which to locate the resource within the classpath.
-  * @param persistTo the name of the file where to store the resource.
-  * @param classToLoadResource the class which will be used to load the resource (@see
+  * @param name
+  *   the name by which to locate the resource within the classpath.
+  * @param persistTo
+  *   the name of the file where to store the resource.
+  * @param classToLoadResource
+  *   the class which will be used to load the resource (@see
   */
-case class BundledResource(name: String, persistTo: Path, classToLoadResource: Class[?] = classOf[BundledResource])
+case class BundledResource(
+    name: String,
+    persistTo: Path,
+    classToLoadResource: Class[?] = classOf[BundledResource]
+)
 
 trait ResourcePersistableInstances {
   def bundledResourceInstance: ResourcePersistable.Aux = new Persistable {
     override type T = BundledResource
     override def path(elem: BundledResource): Path = elem.persistTo
     override def rawText(elem: BundledResource): Array[Byte] =
-      Files.readAllBytes(Paths.get(elem.classToLoadResource.getResource(elem.name).toURI))
+      Files.readAllBytes(
+        Paths.get(elem.classToLoadResource.getResource(elem.name).toURI)
+      )
   }
 }
 

src/main/scala/org/combinators/templating/twirl/Java.scala

@@ -20,7 +20,12 @@ import java.io.StringReader
 
 import com.github.javaparser._
 import com.github.javaparser.ast.`type`.Type
-import com.github.javaparser.ast.body.{BodyDeclaration, ConstructorDeclaration, FieldDeclaration, MethodDeclaration}
+import com.github.javaparser.ast.body.{
+  BodyDeclaration,
+  ConstructorDeclaration,
+  FieldDeclaration,
+  MethodDeclaration
+}
 import com.github.javaparser.ast.expr.{Expression, Name, NameExpr, SimpleName}
 import com.github.javaparser.ast.stmt.Statement
 import com.github.javaparser.ast.{CompilationUnit, ImportDeclaration, Node}
@@ -31,7 +36,8 @@ import scala.collection.immutable._
 import scala.jdk.CollectionConverters._
 
 /** A Java fragment. */
-class Java private(elements: Seq[Java], text: String) extends BufferedContent[Java](elements, text) {
+class Java private (elements: Seq[Java], text: String)
+    extends BufferedContent[Java](elements, text) {
   def this(text: String) = this(Nil, Formats.safe(text))
   def this(elements: Seq[Java]) = this(elements, "")
 
@@ -44,7 +50,8 @@ class Java private(elements: Seq[Java], text: String) extends BufferedContent[Ja
   def compilationUnit(): CompilationUnit = StaticJavaParser.parse(fullText)
 
   /** Parses an import declaration. */
-  def importDeclaration(): ImportDeclaration = StaticJavaParser.parseImport(fullText)
+  def importDeclaration(): ImportDeclaration =
+    StaticJavaParser.parseImport(fullText)
 
   /** Parses this element as a single statement. */
   def statement(): Statement = StaticJavaParser.parseStatement(fullText)
@@ -54,7 +61,8 @@ class Java private(elements: Seq[Java], text: String) extends BufferedContent[Ja
     StaticJavaParser.parseBlock(s"{ $fullText }").getStatements.asScala.to(Seq)
 
   /** Parses this element as an expression. */
-  def expression[T <: Expression](): T = StaticJavaParser.parseExpression[T](fullText)
+  def expression[T <: Expression](): T =
+    StaticJavaParser.parseExpression[T](fullText)
 
   /** Parses this element as a (potentially qualified) name. */
   def name(): Name = StaticJavaParser.parseName(fullText)
@@ -65,12 +73,22 @@ class Java private(elements: Seq[Java], text: String) extends BufferedContent[Ja
   /** Parses this element as a (unqualified) name expression. */
   def nameExpression(): NameExpr = expression()
 
-  /** Parses this element as a class body declaration (e.g. a method or a field). */
-  def classBodyDeclaration(): BodyDeclaration[?] = StaticJavaParser.parseBodyDeclaration(fullText)
+  /** Parses this element as a class body declaration (e.g. a method or a
+    * field).
+    */
+  def classBodyDeclaration(): BodyDeclaration[?] =
+    StaticJavaParser.parseBodyDeclaration(fullText)
 
   /** Parses this element as multiple class body declarations. */
   def classBodyDeclarations(): Seq[BodyDeclaration[?]] =
-    StaticJavaParser.parse(s"class C { $fullText }").getTypes.asScala.head.getMembers.asScala.to(Seq)
+    StaticJavaParser
+      .parse(s"class C { $fullText }")
+      .getTypes
+      .asScala
+      .head
+      .getMembers
+      .asScala
+      .to(Seq)
 
   /** Parses this element as multiple field declarations. */
   def fieldDeclarations(): Seq[FieldDeclaration] =
@@ -84,19 +102,25 @@ class Java private(elements: Seq[Java], text: String) extends BufferedContent[Ja
   def constructors(): Seq[ConstructorDeclaration] =
     classBodyDeclarations().map(_.asInstanceOf[ConstructorDeclaration])
 
-  /** Parses this element as an interface body declaration (e.g. a method signature). */
-  def interfaceBodyDeclaration(): BodyDeclaration[?] = StaticJavaParser.parseBodyDeclaration(fullText)
+  /** Parses this element as an interface body declaration (e.g. a method
+    * signature).
+    */
+  def interfaceBodyDeclaration(): BodyDeclaration[?] =
+    StaticJavaParser.parseBodyDeclaration(fullText)
 
   /** Parses this element as a type (e.g. the in  X foo = (X)bar). */
   def tpe(): Type = StaticJavaParser.parseType(fullText)
 }
 
 /** Helper for Java utility methods. */
 object Java {
+
   /** Creates a Java fragment with initial content specified. */
   def apply(text: String): Java = new Java(text)
 
-  /** Creates a Java fragment with initial content from the given `text` separated by `separator`. */
+  /** Creates a Java fragment with initial content from the given `text`
+    * separated by `separator`.
+    */
   def apply(text: Seq[String], separator: String = ";"): Java = {
     apply(text.mkString(separator))
   }
@@ -105,19 +129,22 @@ object Java {
   def apply(node: Node): Java = Java(node.toString)
 
   /** Creates a Java fragment with initial content from the asts `nodes`. */
-  def apply(nodes: Seq[Node]): Java = new Java(Seq((nodes map apply)*))
+  def apply(nodes: Seq[Node]): Java = new Java(Seq((nodes.map(apply))*))
 }
 
 object JavaFormat extends Format[Java] {
+
   /** Integrates `text` without performing any escaping process.
     *
-    * @param text Text to integrate
+    * @param text
+    *   Text to integrate
     */
   def raw(text: String): Java = Java(text)
 
   /** Escapes `text` using Java String rules.
     *
-    * @param text Text to integrate
+    * @param text
+    *   Text to integrate
     */
   def escape(text: String): Java = Java(StringEscapeUtils.escapeJava(text))
 

src/main/scala/org/combinators/templating/twirl/Python.scala

@@ -21,10 +21,10 @@ import play.twirl.api.{BufferedContent, Format, Formats}
 
 import scala.collection.immutable
 
-/**
-  * A Python fragment.
+/** A Python fragment.
   */
-class Python private(elements: immutable.Seq[Python], text: String) extends BufferedContent[Python](elements, text) {
+class Python private (elements: immutable.Seq[Python], text: String)
+    extends BufferedContent[Python](elements, text) {
   def this(text: String) = this(Nil, Formats.safe(text))
   def this(elements: immutable.Seq[Python]) = this(elements, "")
 
@@ -48,33 +48,36 @@ class Python private(elements: immutable.Seq[Python], text: String) extends Buff
   def getCode: String = fullText
 }
 
-/**
-  * Helper for Python utility methods.
+/** Helper for Python utility methods.
   */
 object Python {
+
   /** Creates a Python fragment with initial content specified. */
   def apply(text: String): Python = {
     new Python(text)
   }
 
-  /** Creates a Python fragment with initial content from the given `text` separated by `separator`. */
+  /** Creates a Python fragment with initial content from the given `text`
+    * separated by `separator`.
+    */
   def apply(text: Seq[String], separator: String = ";"): Python = {
     apply(text.mkString(separator))
   }
 }
 
 object PythonFormat extends Format[Python] {
-  /**
-    * Integrates `text` without performing any escaping process.
+
+  /** Integrates `text` without performing any escaping process.
     *
-    * @param text Text to integrate
+    * @param text
+    *   Text to integrate
     */
   def raw(text: String): Python = Python(text)
 
-  /**
-    * Escapes `text` using Python String rules.
+  /** Escapes `text` using Python String rules.
     *
-    * @param text Text to integrate
+    * @param text
+    *   Text to integrate
     */
   def escape(text: String): Python = Python(StringEscapeUtils.escapeJava(text))
 
@@ -85,4 +88,3 @@ object PythonFormat extends Format[Python] {
   def fill(elements: immutable.Seq[Python]): Python = new Python(elements)
 
 }
-