Release der neuen Architektur

.github/workflows/build.yml

@@ -17,7 +17,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '24'
+          java-version: '25'
 
       - name: Build JAR
         run: mvn clean package -DskipTests

.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '24'
+          java-version: '25'
 
       - name: Determine version bump
         id: bump

.gitignore

@@ -6,4 +6,6 @@ target/
 build
 test.java
 Test.java
-.vscode
+!**/services/Test.java
+.vscode
+sources.json

docs/syntax.md

@@ -0,0 +1,130 @@
+# LVP Syntax
+## Grammatik
+- `[]` -> Optional
+- `::=` -> Definiert als
+- `''` -> Literal
+
+```
+INSTRUCTION ::=     COMMAND | REGISTER | PIPE
+```
+### Command
+```
+COMMAND ::=             COMMANDNAME['{'ID'}']':' CONTENT
+COMMAND ::=             COMMANDNAME['{'ID'}']':' 
+                        CONTENT
+                        '~~~'
+
+COMMANDNAME ::=         STRING
+ID ::=                  STRING
+CONTENT ::=             STRING
+```
+
+Grundidee:
+Aufteilung in Service und Target oder Function und Consumer
+- **Service:** String -> String
+- **Target:** String -> {}
+### Register
+```
+REGISTER ::=    'Register:' COMMANDNAME CALL
+
+CALL ::=        STRING
+```
+
+### Pipe
+```
+PIPE ::= '|' COMMAND ['|' COMMAND '|' ...]
+```
+
+## Targets
+
+- Markdown
+- Html
+- JavaScript
+- JavaScriptCall
+- Clear
+- Dot
+
+### Dot
+```
+Dot:
+[width: WIDTH]
+[height: HEIGHT]
+GRAPH
+~~~
+```
+
+## Default Services
+
+- Text
+- Codeblock
+- Turtle
+- Button
+- Input
+- Checkbox
+- Test
+
+### Turtle
+```
+init XFROM XTO YFROM YTO STARTX STARTY STARTANGLE
+init WIDTH HEIGHT
+
+penup
+pendown
+forward DISTANCE
+backward DISTANCE
+right ANGLE
+left ANGLE
+color R G B [A]
+text TEXT [FONT]
+width WIDTH
+push
+pop
+timeline
+save
+```
+
+### Codeblock
+```
+Codeblock: PATH;LABEL
+
+Codeblock:
+PATH
+LABEL
+~~~
+```
+
+### Test
+```
+Test:
+Send: SNIPPET
+Expect: STRING
+~~~
+```
+
+### Interaction Elements
+```
+Button:
+Text: TEXT
+[width: WIDTH]
+[height: HEIGHT]
+path: PATH
+label: "LABEL"
+replacement: REPLACEMENT
+~~~
+
+Input:
+path: PATH
+label: "LABEL"
+placeholder: PLACEHOLDER
+template: TEMPLATE (with Placeholder '$')
+type: TYPE (Text, Email, Number, etc)
+~~~
+
+Checkbox:
+path: PATH
+label: "LABEL"
+template: TEMPLATE (with Placeholder '$')
+checked: BOOLEAN
+~~~
+```
+

examples/CodeDokuMitMarkdown.java

@@ -1,24 +1,19 @@
-import lvp.Clerk;
-import lvp.skills.Text;
-
 void main() {
-    Clerk.clear();
-    Clerk.markdown("""
-    # Die Code-Dokumentation mit Markdown
-
-    Für die Code-Dokumentation mit Markdown sind Textblöcke und der Text-Skill entscheidende Hilfsmittel.
-
-    * Mit Textblöcken lassen sich String-Literale als Textblöcke über mehrere Zeilen hinweg angeben. Ein solcher Textblock beginnt und endet mit drei Anführungszeichen `\"""`.
+    println("""
+            Clear
+            Markdown:
+            # Die Code-Dokumentation mit Markdown
 
-    * Das LVP bringt einen Text-Skill mit, der hauptsächlich dafür da ist,
-    - um Text aus einer Datei auszuschneiden (Methode `cutOut`); der Bereich, der ausgeschnitten werden soll, wird durch Textmarken (Labels) ausgewiesen.
-    - um Text mit Aufüllfeldern zu versehen (Methode `fillOut`), in die Ergebnisse aus Auswertungen als Zeichenkette eingefügt werden.
+            Für die Code-Dokumentation mit Markdown sind Textblöcke, sowie die Text und Codeblock Kommandos entscheidende Hilfsmittel.
 
-    > In den Java-Versionen 21 und 22 gab es [String-Templates](https://docs.oracle.com/en/java/javase/22/language/string-templates.html) als Preview-Feature. Damit ließen sich sehr elegant die Auswertungen von Ausdrücken mitten in einen String einfügen. Das wird in anderen Programmiersprachen auch als String-Interpolation bezeichnet. Leider sind die String-Templates mit Java 23 wieder entfernt worden -- ein einmaliger Vorgang für Preview-Features in der Historie von Java. Als leichtgewichtigen Ersatz gibt es deshalb im Text-Skill die statische Methode `fillOut`.
+            * Mit Textblöcken lassen sich String-Literale als Textblöcke über mehrere Zeilen hinweg angeben. Ein solcher Textblock beginnt und endet mit drei Anführungszeichen `\"""`.
 
-    """);
-
-
+            * Das Kommando 'Codeblock' ist hauptsächlich dafür da, um Text aus einer Datei auszuschneiden und in einem Markdown Codeblock einzufügen, welcher im Browser editiert werden kann; der Bereich, der ausgeschnitten werden soll, wird durch Textmarken (Labels) ausgewiesen.
+                - Für einen nicht editierbaren Codeblock kann das Kommando `Cutout` verwendet werden.
+            * Das Kommando 'Text' erlaubt es definierte Strings zu speichern und mit Aufüllfeldern versehene Texte, mit weiteren Inhalten aufzufüllen.
+            ~~~
+            """);
+
     // Testfälle
     assert factorial(0) == 1 && factorial(1) == 1;
     assert factorial(2) == 2 && factorial(3) == 6;
@@ -28,132 +23,35 @@ void main() {
     String s = "Die Fakultät von " + (num = 6) + " ist " + factorial(num) + ".";
     // Beispiel
 
-
-
-
-    Clerk.markdown(Text.fillOut("""
-    ## Dynamische Inhalte in Zeichenketten einbetten
-
-    Wenn Inhalte in einer Zeichenkette dynamisch berechnet und eingefügt werden sollen, kann man das beispielsweise wie folgt machen:
-
-    ```
-    ${Beispiel}
-    ```
-
-    Das Ergebnis der Zeichenkette `s` ist
-
-    ```
-    ${Resultat}
-    ```
-
-    Das sieht dann, wenn man die Zeichenkette im Markdown einfügt (mit `Text.fillOut`), so aus: ${Resultat}
-
-    Diese Technik der Einbettung von dynamischen Inhalten in eine Zeichenkette lässt sich ausreizen mit der Text-Skill. Damit kann der Java-Quelltext sich zur Laufzeit selbst ausschneiden zur Einbettung in Markdown! Das ist der Schlüssel zu sich selbst dokumentierendem Programmcode.
-    """, Map.of("Beispiel", Text.cutOut("examples/CodeDokuMitMarkdown.java", "// Beispiel"),
-                "Resultat", s)));
-
-    Clerk.markdown(Text.fillOut(Map.of(
-    "LabelCff",
-    Text.cutOut("examples/CodeDokuMitMarkdown.java", "// LabelCff"),
-    "ResultLabelCff",
-    // LabelCff
-    Text.cutOut("examples/CodeDokuMitMarkdown.java", false, false, "// LabelC")
-    // LabelCff
-    , "LabelCft",
-    Text.cutOut("examples/CodeDokuMitMarkdown.java", "// LabelCft"),
-    "ResultLabelCft",
-    // LabelCft
-    Text.cutOut("examples/CodeDokuMitMarkdown.java", false, true, "// LabelC")
-    // LabelCft
-    , "LabelAB",
-    Text.cutOut("examples/CodeDokuMitMarkdown.java", "// LabelAB"),
-    "ResultLabelAB",
-    // LabelAB
-    Text.cutOut("examples/CodeDokuMitMarkdown.java", "// LabelA", "// LabelB")
-    // LabelAB
-    , "TextCutOut",
-    Text.cutOut("src/main/java/lvp/skills/Text.java", "// core method", "// end")
-    ), """
-    ## Texte ausschneiden mit `Text.cut`
-
-    Mit dem Skill `Text` kann Text aus einer Datei ausgeschnitten werden. Der Methodenkopf von `cutOut` erwartet einen Dateinamen, zwei boolsche Werte und eine beliebige Anzahl an Labels.
-
-    ```
-    static String cutOut(String fileName, boolean includeStartLabel, boolean includeEndLabel, String... labels)
-    ```
-
-    Labels sind Zeichenketten, nach denen als vollständige Textzeile in der angegebenen Datei gesucht wird. Mit den boolschen Werten wird angegeben, ob das öffnende bzw. schliessende Label beim Ausschnitt mit inkludiert, d.h. einbezogen werden soll oder nicht.
-
-    ### Beispiele
+    println("""
+            Text[Template]:
+            ## Dynamische Inhalte in Zeichenketten einbetten
 
-    Nehmen wir eine Datei mit folgendem Inhalt:
+            Wenn Inhalte in einer Zeichenkette dynamisch berechnet und eingefügt werden sollen, kann man das beispielsweise wie folgt machen:
 
-    ```text
-    // LabelA
-    1. Textstelle, gerahmt von einem LabelA und einem LabelB
-    // LabelB
-    // LabelC
-    Textstelle, umschlossen von einem LabelC
-    // LabelC
-    // LabelA
-    2. Textstelle, gerahmt von einem LabelA und einem LabelB
-    // LabelB
-    ```
+            ```
+            ${Beispiel}
+            ```
 
-    Der folgende Aufruf
+            Das Ergebnis der Zeichenkette `s` ist
 
-    ```
-    ${LabelCff}
-    ```
+            ```
+            ${Resultat}
+            ```
 
-    liefert als Zeichenkette diesen Auszug (Snippet) aus der Datei zurück:
-
-    ```
-    ${ResultLabelCff}
-    ```
-
-    > Der Witz an diesem Beispiel ist das, was man hier nicht sieht, aber wichtig für die Idee einer eingebetteten, dynamischen Dokumentation ist: Der obige Aufruf ist tatsächlich ein Snippet von dem Code, der das resultierende Snippet erzeugt. Das klingt ein wenig seltsam, aber das ist genau der Kunstgriff, der garantiert, dass der Aufruf wirklich der ist, der das Ergebnis produziert. Wenn Sie einen Blick in die Java-Datei werfen, die diese View im Browser erzeugt hat, werden Sie das vermutlich verstehen und nachvollziehen können. Vergleichen Sie den Java-Quellcode mit dem Text im Browser.
-
-    Setzt man einen der boolschen Werte auf `true`, wird das entsprechende Label mit übernommen.
-
-    ```
-    ${LabelCft}
-    ```
-
-    Das Ergebnis sieht so aus:
-
-    ```
-    ${ResultLabelCft}
-    ```
-
-    Sind mehrere Stellen mit dem gleichen Label belegt, kann man diese Bereiche ausschneiden. Wenn die boolschen Werte beide `false` sind, kann man den Aufruf verkürzen.
-
-    ```
-    ${LabelAB}
-    ```
-
-    Zunächst wird die erste Textstelle zwischen `LabelA` und `LabelB` ausgeschnitten, dann die zweite.
-
-    ```
-    ${ResultLabelAB}
-    ```
-
-    ### Der Algorithmus zu `Text.cutOut`
-
-    Der Algorithmus zu `Text.cutOut(...)`, um einen Bereich aus einer Textdatei zu schneiden und ein sogenanntes Snippet davon zu erstellen, funktioniert wie folgt:
-
-    0. Starte im Modus, die Textzeilen einer Datei zu überspringen: `skipLines = true`.
-    1. Gehe die Datei Textzeile für Textzeile durch.
-    2. Wenn die Textzeile einem Label entspricht, dann gehe wie folgt vor: (a) Wenn entweder `skipLines` und `includeStartLabel` wahr sind, oder wenn `!skipLines` und `includeEndLabel` wahr sind, dann ergänze die Labelzeile zum Snippet. (b) Wechsel den Modus `skipLines = !skipLines` und gehe zur nächsten Textzeile (Schritt 1).
-    3. Entspricht die Textzeile keinem Label, dann: (a) Füge die Zeile nur dann dem Snippet hinzu, wenn `skipLines` nicht wahr ist. (b) Gehe zur nächsten Textzeile (Schritt 1).
-
-    Als Java-Methode:
-
-    ```java
-    ${TextCutOut}
-    ```
-    """));
+            Das sieht dann, wenn man die Zeichenkette im Markdown einfügt, so aus: ${Resultat}
 
+            Diese Technik der Einbettung von dynamischen Inhalten in eine Zeichenkette lässt sich ausreizen mit den Kommandos `Codeblock` oder `Cutout`. Damit kann der Java-Quelltext sich zur Laufzeit selbst ausschneiden zur Einbettung in Markdown! Das ist der Schlüssel zu sich selbst dokumentierendem Programmcode.
+            ~~~
+            """);
+    println("Text[Resultat]: " + s);
+    println("""
+
+            Codeblock: examples/CodeDokuMitMarkdown.java; // Beispiel
+            | Text[Template] | Text[TemplateMitBeispiel]
+            Text[Resultat]
+            | Text[TemplateMitBeispiel] | Markdown
+            """);
 }
 
 // Fakultätsfunktion
@@ -162,4 +60,4 @@ long factorial(int n) {
     if (n == 1 || n == 0) return 1;
     return n * factorial(n - 1);
 }
-// Ende Fakultätsfunktion
+// Fakultätsfunktion