tidy up root folder

4 files changed, 0 insertions, 256 deletions

diff --git a/twirllib/src/mill/twirllib/TwirlModule.scala b/twirllib/src/mill/twirllib/TwirlModule.scala
deleted file mode 100644
index 2df70a1f..00000000
--- a/twirllib/src/mill/twirllib/TwirlModule.scala
+++ /dev/null
@@ -1,56 +0,0 @@
-package mill
-package twirllib
-
-import coursier.{Cache, MavenRepository}
-import mill.define.Sources
-import mill.eval.PathRef
-import mill.scalalib.Lib.resolveDependencies
-import mill.scalalib._
-import mill.util.Loose
-
-import scala.io.Codec
-import scala.util.Properties
-
-trait TwirlModule extends mill.Module {
-
-  def twirlVersion: T[String]
-
-  def twirlSources: Sources = T.sources {
-    millSourcePath / 'views
-  }
-
-  def twirlClasspath: T[Loose.Agg[PathRef]] = T {
-    resolveDependencies(
-      Seq(
-        Cache.ivy2Local,
-        MavenRepository("https://repo1.maven.org/maven2")
-      ),
-      Lib.depToDependency(_, "2.12.4"),
-      Seq(
-        ivy"com.typesafe.play::twirl-compiler:${twirlVersion()}",
-        ivy"org.scala-lang.modules::scala-parser-combinators:1.1.0"
-      )
-    )
-  }
-
-  // REMIND currently it's not possible to override these default settings
-  private def twirlAdditionalImports: Seq[String] = Nil
-
-  private def twirlConstructorAnnotations: Seq[String] = Nil
-
-  private def twirlCodec: Codec = Codec(Properties.sourceEncoding)
-
-  private def twirlInclusiveDot: Boolean = false
-
-  def compileTwirl: T[CompilationResult] = T.persistent {
-    TwirlWorkerApi.twirlWorker
-      .compile(
-        twirlClasspath().map(_.path),
-        twirlSources().map(_.path),
-        T.ctx().dest,
-        twirlAdditionalImports,
-        twirlConstructorAnnotations,
-        twirlCodec,
-        twirlInclusiveDot)
-  }
-}
diff --git a/twirllib/src/mill/twirllib/TwirlWorker.scala b/twirllib/src/mill/twirllib/TwirlWorker.scala
deleted file mode 100644
index f351ff2f..00000000
--- a/twirllib/src/mill/twirllib/TwirlWorker.scala
+++ /dev/null
@@ -1,119 +0,0 @@
-package mill
-package twirllib
-
-import java.io.File
-import java.lang.reflect.Method
-import java.net.URLClassLoader
-
-import ammonite.ops.{Path, ls}
-import mill.eval.PathRef
-import mill.scalalib.CompilationResult
-
-import scala.io.Codec
-
-class TwirlWorker {
-
-  private var twirlInstanceCache = Option.empty[(Long, TwirlWorkerApi)]
-
-  private def twirl(twirlClasspath: Agg[Path]) = {
-    val classloaderSig = twirlClasspath.map(p => p.toString().hashCode + p.mtime.toMillis).sum
-    twirlInstanceCache match {
-      case Some((sig, instance)) if sig == classloaderSig => instance
-      case _ =>
-        val cl = new URLClassLoader(twirlClasspath.map(_.toIO.toURI.toURL).toArray)
-        val twirlCompilerClass = cl.loadClass("play.twirl.compiler.TwirlCompiler")
-        val compileMethod = twirlCompilerClass.getMethod("compile",
-          classOf[java.io.File],
-          classOf[java.io.File],
-          classOf[java.io.File],
-          classOf[java.lang.String],
-          cl.loadClass("scala.collection.Seq"),
-          cl.loadClass("scala.collection.Seq"),
-          cl.loadClass("scala.io.Codec"),
-          classOf[Boolean])
-
-        val defaultAdditionalImportsMethod = twirlCompilerClass.getMethod("compile$default$5")
-        val defaultConstructorAnnotationsMethod = twirlCompilerClass.getMethod("compile$default$6")
-        val defaultCodecMethod = twirlCompilerClass.getMethod("compile$default$7")
-        val defaultFlagMethod = twirlCompilerClass.getMethod("compile$default$8")
-
-        val instance = new TwirlWorkerApi {
-          override def compileTwirl(source: File,
-                                    sourceDirectory: File,
-                                    generatedDirectory: File,
-                                    formatterType: String,
-                                    additionalImports: Seq[String],
-                                    constructorAnnotations: Seq[String],
-                                    codec: Codec,
-                                    inclusiveDot: Boolean) {
-            val o = compileMethod.invoke(null, source,
-              sourceDirectory,
-              generatedDirectory,
-              formatterType,
-              defaultAdditionalImportsMethod.invoke(null),
-              defaultConstructorAnnotationsMethod.invoke(null),
-              defaultCodecMethod.invoke(null),
-              defaultFlagMethod.invoke(null))
-          }
-        }
-        twirlInstanceCache = Some((classloaderSig, instance))
-        instance
-    }
-  }
-
-  def compile(twirlClasspath: Agg[Path],
-              sourceDirectories: Seq[Path],
-              dest: Path,
-              additionalImports: Seq[String],
-              constructorAnnotations: Seq[String],
-              codec: Codec,
-              inclusiveDot: Boolean)
-             (implicit ctx: mill.util.Ctx): mill.eval.Result[CompilationResult] = {
-    val compiler = twirl(twirlClasspath)
-
-    def compileTwirlDir(inputDir: Path) {
-      ls.rec(inputDir).filter(_.name.matches(".*.scala.(html|xml|js|txt)"))
-        .foreach { template =>
-          val extFormat = twirlExtensionFormat(template.name)
-          compiler.compileTwirl(template.toIO,
-            inputDir.toIO,
-            dest.toIO,
-            s"play.twirl.api.$extFormat",
-            additionalImports,
-            constructorAnnotations,
-            codec,
-            inclusiveDot
-          )
-        }
-    }
-
-    sourceDirectories.foreach(compileTwirlDir)
-
-    val zincFile = ctx.dest / 'zinc
-    val classesDir = ctx.dest / 'html
-
-    mill.eval.Result.Success(CompilationResult(zincFile, PathRef(classesDir)))
-  }
-
-  private def twirlExtensionFormat(name: String) =
-    if (name.endsWith("html")) "HtmlFormat"
-    else if (name.endsWith("xml")) "XmlFormat"
-    else if (name.endsWith("js")) "JavaScriptFormat"
-    else "TxtFormat"
-}
-
-trait TwirlWorkerApi {
-  def compileTwirl(source: File,
-                   sourceDirectory: File,
-                   generatedDirectory: File,
-                   formatterType: String,
-                   additionalImports: Seq[String],
-                   constructorAnnotations: Seq[String],
-                   codec: Codec,
-                   inclusiveDot: Boolean)
-}
-
-object TwirlWorkerApi {
-
-  def twirlWorker = new TwirlWorker()
-}
diff --git a/twirllib/test/resources/hello-world/core/views/hello.scala.html b/twirllib/test/resources/hello-world/core/views/hello.scala.html
deleted file mode 100644
index acadf615..00000000
--- a/twirllib/test/resources/hello-world/core/views/hello.scala.html
+++ /dev/null
@@ -1,6 +0,0 @@
-@(title: String)
-<html>
-    <body>
-        <h1>@title</h1>
-    </body>
-</html>
\ No newline at end of file
diff --git a/twirllib/test/src/mill/twirllib/HelloWorldTests.scala b/twirllib/test/src/mill/twirllib/HelloWorldTests.scala
deleted file mode 100644
index 31928335..00000000
--- a/twirllib/test/src/mill/twirllib/HelloWorldTests.scala
+++ /dev/null
@@ -1,75 +0,0 @@
-package mill.twirllib
-
-import ammonite.ops.{Path, cp, ls, mkdir, pwd, rm, _}
-import mill.util.{TestEvaluator, TestUtil}
-import utest.framework.TestPath
-import utest.{TestSuite, Tests, assert, _}
-
-object HelloWorldTests extends TestSuite {
-
-  trait HelloBase extends TestUtil.BaseModule {
-    override def millSourcePath: Path = TestUtil.getSrcPathBase() / millOuterCtx.enclosing.split('.')
-  }
-
-  trait HelloWorldModule extends mill.twirllib.TwirlModule {
-    def twirlVersion = "1.0.0"
-  }
-
-  object HelloWorld extends HelloBase {
-
-    object core extends HelloWorldModule {
-      override def twirlVersion = "1.3.15"
-    }
-  }
-
-  val resourcePath: Path = pwd / 'twirllib / 'test / 'resources / "hello-world"
-
-  def workspaceTest[T, M <: TestUtil.BaseModule](m: M, resourcePath: Path = resourcePath)
-                                                (t: TestEvaluator[M] => T)
-                                                (implicit tp: TestPath): T = {
-    val eval = new TestEvaluator(m)
-    rm(m.millSourcePath)
-    rm(eval.outPath)
-    mkdir(m.millSourcePath / up)
-    cp(resourcePath, m.millSourcePath)
-    t(eval)
-  }
-
-  def compileClassfiles: Seq[RelPath] = Seq[RelPath](
-    "hello.template.scala"
-  )
-
-  def tests: Tests = Tests {
-    'twirlVersion - {
-
-      'fromBuild - workspaceTest(HelloWorld) { eval =>
-        val Right((result, evalCount)) = eval.apply(HelloWorld.core.twirlVersion)
-
-        assert(
-          result == "1.3.15",
-          evalCount > 0
-        )
-      }
-    }
-    'compileTwirl - workspaceTest(HelloWorld) { eval =>
-      val Right((result, evalCount)) = eval.apply(HelloWorld.core.compileTwirl)
-
-      val outputFiles = ls.rec(result.classes.path)
-      val expectedClassfiles = compileClassfiles.map(
-        eval.outPath / 'core / 'compileTwirl / 'dest / 'html / _
-      )
-      assert(
-        result.classes.path == eval.outPath / 'core / 'compileTwirl / 'dest / 'html,
-        outputFiles.nonEmpty,
-        outputFiles.forall(expectedClassfiles.contains),
-        outputFiles.size == 1,
-        evalCount > 0
-      )
-
-      // don't recompile if nothing changed
-      val Right((_, unchangedEvalCount)) = eval.apply(HelloWorld.core.compileTwirl)
-
-      assert(unchangedEvalCount == 0)
-    }
-  }
-}