# Source-Sets

Ein Source-Set ist eine benannte Gruppe von Quellen und Ressourcen. Elide leitet aus jedem Source-Set Tasks zum
Kompilieren, Testen und Paketieren ab.

## Konventionelles Layout

`main` liegt in `src/main`, `test` in `src/test`, jedes andere Source-Set in `src/<name>`:

| Pfad | Bedeutung |
| --- | --- |
| `src/<set>/java`, `/kotlin`, `/js`, `/ts`, `/python` | Quellen, ein Verzeichnis pro Sprache |
| `src/<set>/resources` | Ressourcen |

- Jedes vorhandene Sprachverzeichnis wird kompiliert. Gibt es keines, ist `src/<set>` selbst die Quellwurzel.
- `src` gilt als `src/main`; `test` oder `tests` als `src/test`.
- `main` und `test` existieren, wenn ihre Verzeichnisse existieren; in einem Projekt, das `android` deklariert, auch
  `androidTest`. Andere Source-Sets müssen deklariert werden.

Dieses Layout braucht keinen `sources`-Block:

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

`elide project info` gibt die aufgelösten Source-Sets aus; `(by convention)` kennzeichnet Pfade aus dem Layout.

## Source-Sets deklarieren

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

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

`new Sources.SourceSetSpec { … }` (mit `import "elide:Sources.pkl" as Sources`) ist die Langform des Eintrags. Pfade
sind projektrelative Globs oder Verzeichnisse; ein Verzeichnis wird rekursiv durchlaufen.

## Vorrang

Jede deklarierte Eigenschaft ersetzt die Konvention nur für diese Eigenschaft.

| Eigenschaft | Weggelassen | Deklariert |
| --- | --- | --- |
| `type` | Aus dem Namen abgeleitet | Wird immer verwendet |
| `paths` | Das konventionelle Layout für den Namen | Wird unverändert verwendet |
| `resources` | `src/<name>/resources`, falls vorhanden | Wird unverändert verwendet |
| `dependsOn` | Test- und Beispiel-Sets sehen `main` | Wird unverändert verwendet; leer bedeutet nichts |

| `type` | Abgeleitet aus | Verhalten |
| --- | --- | --- |
| `test` | `test`, `tests` | Wird von `elide test` ausgeführt; löst `testPackages` auf. |
| `test` | `androidTest` | Android-Instrumented-Tests: werden in ein Test-APK gebaut und auf einem Gerät ausgeführt, nie von `elide test`; löst `androidTestPackages` auf, dazu die Kotlin-Laufzeit, wenn es Kotlin enthält ([Android-Tests](/docs/toolchain/android/testing#instrumented-tests)). |
| `example` | `example`, `examples` | Produktions-Set. |
| `source` | jedem anderen Namen | Produktions-Set. |
| `other` | — | Produktions-Set. |

Artefakte, die keine Quellen nennen, paketieren alle Produktions-Sets. Ein deklariertes Source-Set, dessen Pfade
`src/main` oder `src/test` abdecken, ersetzt das jeweilige konventionelle Set, sodass keine Datei doppelt kompiliert
wird.

## Abhängigkeiten und Classpaths

Produktions-Sets lösen `packages`, `modules`, `compileOnly`, `runtimeOnly` und `processors` auf. Test-Sets fügen
`testPackages` und die Sets hinzu, von denen sie abhängen. Ein Test-Set mit `dependsOn {}` wird ohne die Klassen und
Ressourcen von `main` kompiliert und ausgeführt, löst aber weiterhin `packages` auf. Siehe
[Abhängigkeiten](/docs/toolchain/dependencies#maven-buckets).

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

`elide classpath` löst den Classpath auf und gibt ihn in einer Zeile aus, die Einträge durch `:` getrennt.
Verwendungen: `compile`, `runtime`, `processor`, `modules`, `toolchain`, `provided`; alles andere endet mit Exit-Code
`2`. Die Installation schreibt außerdem `.dev/dependencies/m2/{compile,runtime,test,processors}.classpath`.

Für Tooling lassen sich mehrere Classpaths in einem Aufruf als JSON abfragen:

```bash
elide classpath --json main:compile test:compile
```

Das Ergebnis ist ein Objekt mit jeder angefragten Query als Schlüssel und einem Array von Pfad-Strings als Wert.
Queries werden unabhängig aufgelöst. Ohne Query liefert `--json` `{"main:compile": [...]}`.

## Ressourcen

Auf der JVM liegen Ressourcen bei Ausführungen und Tests auf dem Classpath und werden in JARs kopiert.

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

Ein einfacher Pfad wird in die Wurzel der Ausgabe kopiert. `from` (ein Verzeichnis oder eine Datei) wird unter `into`
kopiert: aus `config/services/app.Service` wird `META-INF/services/app.Service`. `into` ist standardmäßig die Wurzel.

## Artefakte

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

Quell- und Javadoc-JARs folgen derselben Regel. Die `resources` eines JAR kommen zu denen seiner Sets hinzu. Siehe
[JAR-Erstellung](/docs/toolchain/jvm/jar).

## Sprachen

Die Dateiendung bestimmt die Sprache: `.java`, `.kt`, `.js`/`.mjs`/`.cjs`/`.jsx`,
`.ts`/`.mts`/`.cts`/`.tsx`, `.py`. Ein Set mit Java und Kotlin führt beide Compiler aus; ein Set ohne beide führt keine
JVM-Kompilierung aus. Compiler-Einstellungen für ein Set gehören in den Block der Sprache, mit dem Namen des Sets als
Schlüssel: `jvm.java.sourceSets` (siehe [Java-Compiler](/docs/toolchain/jvm/javac#build-projects)).
Kotlin-Skripte (`.kts`) in einem Set zählen als Kotlin-Quellen, erzeugen aber keine Klassen und werden nicht
typgeprüft.
