Skip to content
This repository was archived by the owner on Nov 7, 2026. It is now read-only.

Commit c109bb4

Browse files
VisuObject: Projekt mit Packages, Oberfläche wie WebGoatCode, Beziehungen mit Objektinspektor (#172)
* VisuObject: Projekt mit Packages und Package Explorer Links ein Baum wie der Package Explorer in Eclipse, im modernen Look: Projekt › src › Packages › Dateien › Klassen › Attribute/Methoden. Jede Ebene und die ganze Spalte lassen sich einklappen. Eine Datei pro Klasse, die Zeile package folgt dem Ordner. Das Klassendiagramm zeigt alle Klassen und jedes Package als UML-Rahmen; die Blöcke stehen nebeneinander, wenn Platz ist. Öffnen und Speichern als ZIP (Name/src/package/Klasse.java). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ugz28SuLhbcLydch8nbzdQ * VisuObject: Oberfläche wie WebGoatCode, Beziehungen ziehen und Objektinspektor - Flache Bereiche mit Kopfleiste und „–“ zum Einklappen (Streifen mit Namen), Schieber zwischen den Bereichen, Datei-Reiter über dem Code - Beziehung vom Griff am gewählten Kasten zu einer anderen Klasse ziehen: Assoziation, Aggregation, Komposition, Vererbung, Realisierung - Objektinspektor für Beziehungen: Art, Name mit Leserichtung, Navigierbarkeit (eine/beide Richtungen, ohne Pfeil), Rollen und Multiplizitäten an beiden Enden; Java-Teile (Attribut, Typ, Liste, Import) im Code, UML-Zusatz in uml am Projekt bzw. visuobject.json - Rolle und Multiplizität gleich weit von der Klasse, Name der Beziehung auf einem freien Stück der Linie Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ugz28SuLhbcLydch8nbzdQ --------- Co-authored-by: Claude <noreply@anthropic.com>
1 parent 4052c6b commit c109bb4

26 files changed

Lines changed: 3095 additions & 356 deletions

‎web/README.md‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -93,3 +93,8 @@ Dritte Welt neben VisuStruct und VisuBot, für Objektorientierung ab Klasse 12 (
9393
`src/ui/objectApp.ts` zeigt links den Java-Code (CodeMirror wie in „Programmieren“) und rechts das Klassendiagramm.
9494
`src/core/classModel.ts` liest Klassen, Attribute, Methoden-Köpfe, `extends` und `implements` aus dem Code und schreibt
9595
Änderungen im Diagramm an genau diese Stelle zurück (Rümpfe, Startwerte und Kommentare bleiben). Tests: `test/classModel.test.ts`.
96+
Ein Projekt hat mehrere Dateien in Packages (`src/core/javaProject.ts`, eine Datei pro Klasse, die Zeile `package …;` folgt
97+
dem Ordner). Links zeigt der Package Explorer Projekt › src › Packages › Dateien › Klassen › Attribute/Methoden; jede Ebene
98+
und die ganze Spalte lassen sich einklappen. Das Klassendiagramm zeigt alle Klassen, jedes Package als UML-Rahmen.
99+
Öffnen und Speichern als ZIP wie aus Eclipse oder BlueJ (`Name/src/package/Klasse.java`, `src/ui/projectZip.ts`, fflate).
100+
Tests: `test/javaProject.test.ts`.

‎web/package-lock.json‎

Lines changed: 4 additions & 4 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎web/package.json‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727
"@codemirror/state": "^6.7.6",
2828
"@codemirror/view": "^6.43.15",
2929
"@lezer/highlight": "^1.2.5",
30+
"fflate": "^0.8.2",
3031
"three": "^0.181.2"
3132
}
3233
}

‎web/src/core/classModel.ts‎

Lines changed: 34 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -343,7 +343,7 @@ export function parseClasses(source: string): UmlClass[] {
343343
}
344344

345345
/** Elementtyp von Behältern: `Hund[]`, `ArrayList<Hund>`, `List<Hund>` → `Hund` mit `0..*`. */
346-
function associationTarget(type: string): { name: string; many: boolean } {
346+
export function associationTarget(type: string): { name: string; many: boolean } {
347347
const array = /^([\p{L}_$][\p{L}\p{N}_$]*)(\[\])+$/u.exec(type)
348348
if (array) return { name: array[1], many: true }
349349
const generic = /^(?:ArrayList|LinkedList|List|Set|HashSet|TreeSet|Collection|Queue|Deque|ArrayDeque|Stack|Vector)<([\p{L}_$][\p{L}\p{N}_$]*)>$/u.exec(type)
@@ -520,6 +520,39 @@ export function setSuperclass(source: string, cls: UmlClass, superclass: string
520520
return splice(source, cls.headerFrom, cls.headerTo, before + after)
521521
}
522522

523+
/** Interface hinzufügen: `implements` bei Klassen, `extends` bei Interfaces. */
524+
export function addInterface(source: string, cls: UmlClass, name: string): string {
525+
if (cls.interfaces.includes(name)) return source
526+
const head = source.slice(cls.headerFrom, cls.headerTo)
527+
const word = cls.kind === 'interface' ? 'extends' : 'implements'
528+
const list = new RegExp(`\\b${word}\\s+[\\p{L}_$][\\p{L}\\p{N}_$<>,\\s]*?(?=\\s*$)`, 'u')
529+
const changed = list.test(head) ? head.replace(list, (m) => `${m.replace(/\s+$/, '')}, ${name}`) : `${head.replace(/\s+$/, '')} ${word} ${name}${/\s$/.test(head) ? ' ' : ''}`
530+
return splice(source, cls.headerFrom, cls.headerTo, changed)
531+
}
532+
533+
/** Interface aus `implements` (bzw. `extends` beim Interface) streichen; leere Liste fällt weg. */
534+
export function removeInterface(source: string, cls: UmlClass, name: string): string {
535+
if (!cls.interfaces.includes(name)) return source
536+
const head = source.slice(cls.headerFrom, cls.headerTo)
537+
const word = cls.kind === 'interface' ? 'extends' : 'implements'
538+
const list = new RegExp(`\\s*\\b${word}\\s+([\\p{L}_$][\\p{L}\\p{N}_$<>,\\s]*?)(?=\\s*$)`, 'u')
539+
const changed = head.replace(list, (_m, names: string) => {
540+
const rest = names.split(',').map((n) => n.trim()).filter((n) => n && n !== name)
541+
return rest.length ? ` ${word} ${rest.join(', ')}` : ''
542+
})
543+
return splice(source, cls.headerFrom, cls.headerTo, changed)
544+
}
545+
546+
/** Typ eines Attributs ändern, mit neuem Startwert (oder keinem). Modifizierer und Name bleiben. */
547+
export function setFieldType(source: string, member: UmlMember, type: string, init?: string): string {
548+
if (member.kind !== 'field' || member.shared) return source
549+
const head = source.slice(member.headerFrom, member.headerTo)
550+
const typeAt = head.lastIndexOf(member.type, member.nameFrom - member.headerFrom)
551+
if (typeAt < 0) return source
552+
const newHead = head.slice(0, typeAt) + type + head.slice(typeAt + member.type.length)
553+
return splice(source, member.headerFrom, member.to, `${newHead}${init ? ` = ${init}` : ''};`)
554+
}
555+
523556
/** Abstrakt an- oder ausschalten (nur bei Klassen). */
524557
export function setAbstract(source: string, cls: UmlClass, abstract: boolean): string {
525558
const head = source.slice(cls.headerFrom, cls.headerTo)

‎web/src/core/javaProject.ts‎

Lines changed: 232 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,232 @@
1+
/**
2+
* VisuObject: ein Java-Projekt aus mehreren Dateien, wie im Package Explorer von Eclipse.
3+
* Jede Datei liegt in einem Package (Ordner); die Zeile `package …;` im Code folgt dem Ordner.
4+
* Das Klassendiagramm zeigt die Klassen aller Dateien.
5+
*/
6+
7+
import { parseClasses, type UmlClass } from './classModel'
8+
import type { UmlInfo } from './umlRelations'
9+
10+
export interface ProjectFile {
11+
/** Pfad unter `src/`, z. B. `tiere/Hund.java`; ohne Ordner im Standard-Package. */
12+
path: string
13+
text: string
14+
}
15+
16+
export interface JavaProject {
17+
name: string
18+
files: ProjectFile[]
19+
/** Auch leere Packages, z. B. gleich nach „+ Package“. */
20+
packages: string[]
21+
/** Was nur UML kennt (Aggregation, Name der Beziehung …), siehe `umlRelations.ts`. */
22+
uml?: UmlInfo
23+
}
24+
25+
/** Klasse mit Datei und Package, für Diagramm und Explorer. */
26+
export interface ProjectClass extends UmlClass {
27+
path: string
28+
pkg: string
29+
}
30+
31+
export const packageOf = (path: string) => (path.includes('/') ? path.slice(0, path.lastIndexOf('/')).replace(/\//g, '.') : '')
32+
export const fileNameOf = (path: string) => path.slice(path.lastIndexOf('/') + 1)
33+
export const pathFor = (pkg: string, file: string) => (pkg ? `${pkg.replace(/\./g, '/')}/${file}` : file)
34+
35+
const packageName = /^[a-z_$][\p{L}\p{N}_$]*(\.[a-z_$][\p{L}\p{N}_$]*)*$/u
36+
export const isPackageName = (name: string) => packageName.test(name)
37+
38+
/** Alle Packages: aus den Dateien und die leeren, sortiert; das Standard-Package nur, wenn Dateien darin liegen. */
39+
export function packagesOf(project: JavaProject): string[] {
40+
const all = new Set(project.packages)
41+
for (const f of project.files) all.add(packageOf(f.path))
42+
return [...all].filter((p) => p !== '' || project.files.some((f) => packageOf(f.path) === '')).sort((a, b) => (a === '' ? 1 : b === '' ? -1 : a.localeCompare(b)))
43+
}
44+
45+
export function filesIn(project: JavaProject, pkg: string): ProjectFile[] {
46+
return project.files.filter((f) => packageOf(f.path) === pkg).sort((a, b) => a.path.localeCompare(b.path))
47+
}
48+
49+
/** `package …;` am Anfang setzen, ändern oder (Standard-Package) entfernen. */
50+
export function withPackageLine(text: string, pkg: string): string {
51+
const line = /^(\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*)package\s+[\w.]+\s*;[ \t]*\n?/
52+
const match = line.exec(text)
53+
if (match) {
54+
if (!pkg) return match[1] + text.slice(match[0].length).replace(/^\n/, '')
55+
return `${match[1]}package ${pkg};\n` + text.slice(match[0].length)
56+
}
57+
if (!pkg) return text
58+
return `package ${pkg};\n\n${text.replace(/^\n+/, '')}`
59+
}
60+
61+
/** Package aus der Zeile `package …;` lesen (für geöffnete Dateien). */
62+
export function declaredPackage(text: string): string {
63+
return /^\s*(?:(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)\s*)*package\s+([\w.]+)\s*;/.exec(text)?.[1] ?? ''
64+
}
65+
66+
export function projectClasses(project: JavaProject): ProjectClass[] {
67+
return project.files.flatMap((f) => parseClasses(f.text).map((c) => ({ ...c, path: f.path, pkg: packageOf(f.path) })))
68+
}
69+
70+
export function updateFile(project: JavaProject, path: string, text: string): JavaProject {
71+
return { ...project, files: project.files.map((f) => (f.path === path ? { ...f, text } : f)) }
72+
}
73+
74+
export function addFile(project: JavaProject, path: string, text: string): JavaProject {
75+
return { ...project, files: [...project.files.filter((f) => f.path !== path), { path, text }] }
76+
}
77+
78+
export function removeFile(project: JavaProject, path: string): JavaProject {
79+
// Das Package bleibt sichtbar, auch wenn es jetzt leer ist.
80+
const pkg = packageOf(path)
81+
return { ...project, files: project.files.filter((f) => f.path !== path), packages: pkg && !project.packages.includes(pkg) ? [...project.packages, pkg] : project.packages }
82+
}
83+
84+
/** Datei umbenennen oder in ein anderes Package schieben; die `package`-Zeile passt sich an. */
85+
export function moveFile(project: JavaProject, path: string, to: string): JavaProject {
86+
const pkg = packageOf(to)
87+
return {
88+
...project,
89+
files: project.files.map((f) => (f.path === path ? { path: to, text: packageOf(path) === pkg ? f.text : withPackageLine(f.text, pkg) } : f)),
90+
}
91+
}
92+
93+
export function addPackage(project: JavaProject, pkg: string): JavaProject {
94+
return project.packages.includes(pkg) ? project : { ...project, packages: [...project.packages, pkg] }
95+
}
96+
97+
/** Package umbenennen (auch Unter-Packages wie `tiere.haus`). */
98+
export function renamePackage(project: JavaProject, from: string, to: string): JavaProject {
99+
const rename = (p: string) => (p === from ? to : p.startsWith(from + '.') ? to + p.slice(from.length) : p)
100+
return {
101+
...project,
102+
packages: [...new Set(project.packages.map(rename))],
103+
files: project.files.map((f) => {
104+
const pkg = packageOf(f.path)
105+
const next = rename(pkg)
106+
return next === pkg ? f : { path: pathFor(next, fileNameOf(f.path)), text: withPackageLine(f.text, next) }
107+
}),
108+
}
109+
}
110+
111+
/** Package samt Dateien löschen. */
112+
export function removePackage(project: JavaProject, pkg: string): JavaProject {
113+
return { ...project, packages: project.packages.filter((p) => p !== pkg), files: project.files.filter((f) => packageOf(f.path) !== pkg) }
114+
}
115+
116+
/** Neue Datei für eine Klasse: `package …;` und ein leerer Rumpf. */
117+
export function classFileText(pkg: string, name: string, kind: 'class' | 'interface'): string {
118+
return withPackageLine(`public ${kind} ${name} {\n}\n`, pkg)
119+
}
120+
121+
/** Eine einzelne Datei (z. B. aus Stufe 1 oder ein geöffnetes `.java`) als Projekt. */
122+
export function projectFromFiles(name: string, files: { name: string; text: string }[]): JavaProject {
123+
const out: ProjectFile[] = []
124+
for (const f of files) {
125+
const text = f.text.replace(/\r\n/g, '\n')
126+
const pkg = declaredPackage(text)
127+
const publicClass = /\bpublic\s+(?:abstract\s+|final\s+)*(?:class|interface|enum)\s+(\w+)/.exec(text)?.[1]
128+
const fileName = /\.java$/i.test(f.name) ? fileNameOf(f.name) : `${publicClass ?? parseClasses(text)[0]?.name ?? 'Main'}.java`
129+
out.push({ path: pathFor(pkg, fileName), text })
130+
}
131+
return { name, files: out, packages: [] }
132+
}
133+
134+
/** Speichern im Browser und als `.visuobject`-Datei. */
135+
export function projectToJSON(project: JavaProject): string {
136+
return JSON.stringify({ format: 'visuobject', version: 1, ...project })
137+
}
138+
139+
export function projectFromJSON(json: string): JavaProject | undefined {
140+
try {
141+
const data = JSON.parse(json) as Partial<JavaProject>
142+
if (!Array.isArray(data.files)) return undefined
143+
const files = data.files.filter((f): f is ProjectFile => typeof f?.path === 'string' && typeof f?.text === 'string')
144+
const project: JavaProject = { name: typeof data.name === 'string' && data.name ? data.name : 'Projekt', files, packages: Array.isArray(data.packages) ? data.packages.filter((p) => typeof p === 'string') : [] }
145+
const uml = umlFromJSON(data.uml)
146+
if (uml) project.uml = uml
147+
return project
148+
} catch {
149+
return undefined
150+
}
151+
}
152+
153+
/** Nur Einträge mit Objekt als Wert übernehmen (Datei kann von außen kommen). */
154+
export function umlFromJSON(data: unknown): UmlInfo | undefined {
155+
if (!data || typeof data !== 'object' || Array.isArray(data)) return undefined
156+
const out: UmlInfo = {}
157+
for (const [key, value] of Object.entries(data as Record<string, unknown>)) if (value && typeof value === 'object' && !Array.isArray(value)) out[key] = value as UmlInfo[string]
158+
return Object.keys(out).length ? out : undefined
159+
}
160+
161+
// MARK: - Beispiel
162+
163+
/** Beispiel wie im Spickzettel Java OOP & UML: Tier und Hund im Package `tiere`, Besitzer in `personen`. */
164+
export function exampleProject(): JavaProject {
165+
return {
166+
name: 'Zoo',
167+
packages: [],
168+
uml: { 'Besitzer.hunde': { kind: 'aggregation', name: 'führt aus', reading: 'forward', sourceMultiplicity: '1' } },
169+
files: [
170+
{
171+
path: 'tiere/Tier.java',
172+
text: `package tiere;
173+
174+
public class Tier {
175+
private String name;
176+
private int alter;
177+
178+
public Tier(String name, int alter) {
179+
this.name = name;
180+
this.alter = alter;
181+
}
182+
183+
public String getName() {
184+
return name;
185+
}
186+
187+
public void lautGeben() {
188+
System.out.println("...");
189+
}
190+
}
191+
`,
192+
},
193+
{
194+
path: 'tiere/Hund.java',
195+
text: `package tiere;
196+
197+
public class Hund extends Tier {
198+
private String rasse;
199+
200+
public Hund(String name, int alter, String rasse) {
201+
super(name, alter);
202+
this.rasse = rasse;
203+
}
204+
205+
public void lautGeben() {
206+
System.out.println("Wuff");
207+
}
208+
}
209+
`,
210+
},
211+
{
212+
path: 'personen/Besitzer.java',
213+
text: `package personen;
214+
215+
import java.util.ArrayList;
216+
import tiere.Hund;
217+
218+
public class Besitzer {
219+
private String name;
220+
private ArrayList<Hund> hunde = new ArrayList<>();
221+
222+
public void gassiGehen() {
223+
for (Hund h : hunde) {
224+
h.lautGeben();
225+
}
226+
}
227+
}
228+
`,
229+
},
230+
],
231+
}
232+
}

0 commit comments

Comments
 (0)