ammonite.interp.script.Script.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ammonite-interp_2.12.18 Show documentation
ammonite-interp
The newest version!
package ammonite.interp.script

import ammonite.util.Imports
import ammonite.util.Util.CodeSource
import ammonite.runtime.ImportHook
import ammonite.util.Name

final case class Script(
    code: String,
    codeSource: CodeSource,
    blocks: Seq[Script.Block],
    processorDiagnostics: Seq[Diagnostic]
) {

  lazy val dependencyImports: Imports = {
    val importData = dependencies.scriptDependencies.flatMap(_.hookImports.value)
    Imports(importData)
  }

  lazy val dependencies: Script.Dependencies =
    blocks
      .flatMap(_.imports)
      .map(Script.dependencies)
      .foldLeft(Script.Dependencies())(_ + _)
      .noDuplicates

  lazy val options: Script.Options =
    Script.Options() // TODO Add $imports for that

  def segments(wd: Option[os.Path]): Option[Seq[String]] =
    for {
      p <- codeSource.path
      segments = wd.fold(p.segments.toVector)(wd0 => p.relativeTo(wd0).segments.toVector)
    } yield segments

  def generatedScalaPath(clsName: Name): Seq[String] =
    codeSource.pkgName.map(_.encoded) :+ s"${clsName.encoded}.scala"
}

object Script {

  final case class Import(
      code: Either[String, os.Path],
      isExec: Boolean,
      codeSource: CodeSource,
      hookImports: Imports
  )

  final case class Dependencies(
      scriptDependencies: Seq[Script.Import] = Nil,
      dependencies: Seq[coursierapi.Dependency] = Nil,
      jarDependencies: Seq[os.Path] = Nil,
      pluginDependencies: Seq[coursierapi.Dependency] = Nil,
      jarPluginDependencies: Seq[os.Path] = Nil,
      extraRepositories: Seq[coursierapi.Repository] = Nil
  ) {
    def +(other: Dependencies): Dependencies =
      Dependencies(
        scriptDependencies ++ other.scriptDependencies,
        dependencies ++ other.dependencies,
        jarDependencies ++ other.jarDependencies,
        pluginDependencies ++ other.pluginDependencies,
        jarPluginDependencies ++ other.jarPluginDependencies,
        extraRepositories ++ other.extraRepositories
      )
    def noDuplicates: Dependencies =
      Dependencies(
        scriptDependencies.distinct,
        dependencies.distinct,
        jarDependencies.distinct,
        pluginDependencies.distinct,
        jarPluginDependencies.distinct,
        extraRepositories.distinct
      )
  }

  final case class Options(
      extraScalacOptions: Seq[String] = Nil
  ) {
    def +(other: Options): Options =
      Options(
        extraScalacOptions ++ other.extraScalacOptions
      )
    def noDuplicates: Options =
      Options(
        extraScalacOptions.distinct
      )
  }

  final case class Block(
      startIdx: Int,
      leadingSpaces: String,
      statements: Seq[String],
      imports: Seq[ImportHook.Result]
  )

  final case class ResolvedDependencies(
      jars: Seq[os.Path],
      pluginJars: Seq[os.Path],
      byteCode: Seq[(String, Array[Byte])]
  )

  private def dependencies(hookRes: ImportHook.Result): Dependencies =
    hookRes match {
      case cp: ImportHook.Result.ClassPath =>
        cp.origin match {
          case Some(deps) =>
            if (cp.plugin)
              Dependencies(pluginDependencies = deps)
            else
              Dependencies(dependencies = deps)
          case None =>
            if (cp.plugin)
              Dependencies(jarPluginDependencies = cp.files)
            else
              Dependencies(jarDependencies = cp.files)
        }
      case s: ImportHook.Result.Source =>
        s.codeSource.path match {
          case Some(p) =>
            Dependencies(
              scriptDependencies =
                Seq(Import(Right(p), s.exec, s.codeSource, s.hookImports))
            )
          case None =>
            Dependencies() // TODO import $url
        }
      case ImportHook.Result.Repo(r) =>
        Dependencies(extraRepositories = Seq(r))
    }

}