Conjuntos de fuentes

Un conjunto de fuentes es un grupo con nombre de fuentes y recursos. Elide deriva de cada uno las tareas de compilación, prueba y empaquetado.

Estructura convencional

main está en src/main, test en src/test y cualquier otro conjunto en src/<name>:

• Se compila cada directorio de lenguaje que exista. Si no hay ninguno, el propio src/<set> es la raíz de fuentes.
• src se usa como src/main; test o tests, como src/test.
• main y test existen cuando existen sus directorios. Los demás conjuntos deben declararse.

Esta estructura no necesita un bloque sources:

src/main/kotlin/sample/Main.kt
src/main/resources/app.properties
src/test/kotlin/sample/MainTest.kt

elide project info muestra los conjuntos resueltos; (by convention) marca las rutas que vienen de la estructura.

Declarar conjuntos de fuentes

sources {
  // A glob moves only the sources.
  ["main"] = "lib/**/*.kt"

  // A block sets more properties.
  ["integrationTest"] {
    type = "test"
    paths { "it/**/*.kt" }
  }
}

new Sources.SourceSetSpec { … } (con import "elide:Sources.pkl" as Sources) es la forma larga de la entrada. Las rutas son globs o directorios relativos al proyecto; un directorio se recorre de forma recursiva.

Precedencia

Cada propiedad declarada reemplaza la convención solo para esa propiedad.

Los artefactos que no nombran fuentes empaquetan todos los conjuntos de producción. Un conjunto declarado cuyas rutas cubren src/main o src/test reemplaza ese conjunto convencional, de modo que ningún archivo se compila dos veces.

Dependencias y classpath

Los conjuntos de producción resuelven packages, modules, compileOnly, runtimeOnly y processors. Los conjuntos de prueba añaden testPackages y los conjuntos de los que dependen. Un conjunto de prueba con dependsOn {} se compila y se ejecuta sin las clases ni los recursos de main, pero sigue resolviendo packages. Consulte Dependencias.

elide classpath                 # main:compile
elide classpath runtime         # main:runtime
elide classpath test:runtime    # [<source-set>:]<usage>

elide classpath resuelve el classpath y lo imprime en una sola línea, con las entradas separadas por :. Usos: compile, runtime, processor, modules, toolchain, provided; cualquier otro valor sale con 2. La instalación también escribe .dev/dependencies/m2/{compile,runtime,test,processors}.classpath.

Recursos

En la JVM, los recursos están en el classpath durante las ejecuciones y las pruebas, y se copian en los JAR.

sources {
  ["main"] {
    resources {
      "assets/banner.txt"
      new {
        from = "config/services"
        into = "META-INF"
      }
    }
  }
}

Una ruta simple se copia en la raíz de la salida. from (un directorio o un archivo) se copia bajo into: config/services/app.Service pasa a ser META-INF/services/app.Service. into es la raíz de forma predeterminada.

Artefactos

artifacts {
  ["app"] = new Jvm.Jar {}                 // every non-test source set
  ["lib"] = new Jvm.Jar { sources { "api" } }
}

Los JAR de fuentes y de Javadoc siguen la misma regla. Los resources de un JAR se suman a los de sus conjuntos. Consulte Ensamblado de JAR.

Lenguajes

La extensión del archivo determina el lenguaje: .java, .kt, .js/.mjs/.cjs/.jsx, .ts/.mts/.cts/.tsx, .py. Un conjunto con Java y Kotlin ejecuta ambos compiladores; un conjunto sin ninguno de los dos no ejecuta compilación JVM. La configuración del compilador para un conjunto va en el bloque del lenguaje, con el nombre del conjunto como clave: jvm.java.sourceSets (consulte Compilador Java). Los scripts de Kotlin (.kts) de un conjunto cuentan como fuentes de Kotlin, pero no producen clases ni se comprueban sus tipos.