davide
d9f16f2844
docs/ descrive il programma com'e' adesso, non com'e' stato: e' la prima cosa che si legge per capirlo, quindi un doc che racconta un comportamento che non esiste piu' fa prendere decisioni sbagliate - e' peggio di un doc mancante. Aggiunta la regola, la tabella di quale doc ospita cosa, e la richiesta di annotare anche il sintomo quando il cambiamento nasce da un fallimento di Creo: i suoi messaggi non nominano ne' il file ne' la causa, e senza quel ponte la volta dopo si riparte da zero.
125 lines
7.0 KiB
Markdown
125 lines
7.0 KiB
Markdown
# CLAUDE.md
|
|
|
|
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
|
|
|
|
## Cos'è questo progetto
|
|
|
|
`PrepStep` è il nome tecnico del progetto (cartella, namespace, csproj, eseguibile
|
|
`PrepStep.exe`); il nome mostrato all'utente finale è **Cevolani StepPrep** (`<Product>`/
|
|
`<AssemblyTitle>` in `PrepStep/PrepStep.csproj`, usato nel titolo della finestra insieme
|
|
alla versione, `<Version>`, attualmente `0.1.0`). È un'app Windows Forms (.NET 10, WinForms) che indicizza e permette di
|
|
cercare i file CAD Pro-ENGINEER/Creo contenuti in tutte le cartelle di primo livello
|
|
di un disco/share di rete (radice di default `X:\`), salvando i metadati in un DB
|
|
SQLite locale (`cad_index.db`). Il flusso a valle (fasi 2-5, vedi sotto) prepara i file
|
|
`raw/` da passare a Creo Distributed Batch per l'esportazione STEP: la app è quindi un
|
|
pre-processo per quel passaggio, non lo sostituisce.
|
|
|
|
## Comandi
|
|
|
|
Tutti da eseguire dentro `PrepStep/`.
|
|
|
|
```powershell
|
|
dotnet build -c Release
|
|
dotnet run -c Release
|
|
```
|
|
|
|
Pubblicazione come eseguibile standalone (single-file, self-contained, Windows x64):
|
|
|
|
```powershell
|
|
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -o publish
|
|
```
|
|
|
|
`PrepStep.Tests/` (xUnit) contiene unit e integration test — vedi
|
|
`dotnet test` da dentro quella cartella. Riferimento al progetto principale
|
|
via `ProjectReference` + `InternalsVisibleTo` (in `PrepStep.csproj`), così
|
|
i test possono chiamare direttamente `Indexer.ParseFilename` e
|
|
`AssemblyComponentScanner.EstraiCodiciReferenziati` senza esporli come API
|
|
pubblica.
|
|
|
|
## Documentazione: va tenuta allineata
|
|
|
|
`docs/` non è un archivio di note storiche: descrive **il programma com'è adesso**, ed è la
|
|
prima cosa che si legge per capirlo. Ogni modifica strutturale — un passo in più o in meno nel
|
|
flusso delle fasi, un nuovo modo di leggere il `.asm`, un cambio nello schema del DB o nel
|
|
criterio con cui si sceglie un file — va riflessa nei doc **nello stesso commit** del codice,
|
|
non "dopo". Un doc che descrive un comportamento che non esiste più è peggio di un doc
|
|
mancante: fa prendere decisioni sbagliate.
|
|
|
|
Dove scrivere cosa:
|
|
|
|
| Doc | Contenuto |
|
|
|---|---|
|
|
| `CLAUDE.md` (questo file) | il flusso essenziale e i punti che si sbaglierebbero senza saperli |
|
|
| [`docs/architettura.md`](docs/architettura.md) | il processo delle 5 fasi e la mappa file-per-file |
|
|
| [`docs/formato-asm-record.md`](docs/formato-asm-record.md) | parser esatto dei record `.asm`, con §7 per i casi limite |
|
|
| [`docs/formato-asm.md`](docs/formato-asm.md) | euristica testuale di fallback |
|
|
| [`docs/db-cad-index.md`](docs/db-cad-index.md) | schema e vista di `cad_index.db` |
|
|
| [`docs/copia-raw-parallela.md`](docs/copia-raw-parallela.md) | parallelizzazione della copia in `raw/` |
|
|
|
|
Quando il cambiamento nasce da un fallimento reale di Creo, scrivere anche **il sintomo**: i
|
|
messaggi di Creo non nominano il file o la causa, e senza quel ponte la prossima volta si
|
|
riparte da zero (i §7.3/§7.4/§7.5 di `formato-asm-record.md` sono l'esempio del formato
|
|
atteso).
|
|
|
|
## Architettura
|
|
|
|
Il programma è tutto in `PrepStep/` (nessun altro progetto nella solution). Dettaglio
|
|
completo file-per-file in [`docs/architettura.md`](docs/architettura.md); qui solo il flusso
|
|
che conta per capire il prodotto.
|
|
|
|
`Form1.cs` è un wizard a 5 fasi (una sola visibile alla volta, `_panelFasi[]`, si avanza con
|
|
"Avanti" solo se `AvantiConsentito`), UI costruita interamente in codice (`BuildUi`, nessun
|
|
designer visuale):
|
|
|
|
1. **Database** — carica/aggiorna `cad_index.db` (`Indexer.ScanAsync`, radice disco di
|
|
default `X:\` hardcoded in `RadiceDiscoDefault`); qui vive anche la **cartella di lavoro**
|
|
(destinazione di CSV/`raw/`/`step/`), proposta dall'ultima usata o dalla cartella del DB se
|
|
non c'è ancora nulla di salvato — vedi `docs/db-cad-index.md` per il dettaglio di schema e
|
|
risoluzione del percorso DB.
|
|
2. **Importa Distinta Base** — `DistintaBaseImporter.ConvertiInCsv` genera il CSV
|
|
componente;descrizione nella cartella di lavoro; se il file segue la convenzione del
|
|
gestionale (`DBP_<codice>_<timestamp>`), aggiunge l'assieme generale come riga in più (da
|
|
quel momento è un componente come tutti gli altri, nessun caso speciale nel resto del
|
|
codice).
|
|
3. **Crea cartella raw** — `TrovaPercorsiCad` + `CopiaFileTrovati` (parallela, vedi
|
|
`docs/copia-raw-parallela.md`) copiano in `raw/` i file CAD dei componenti del CSV trovati
|
|
nell'indice.
|
|
4. **Trova componenti referenziati** — legge i `.asm` in `raw/` per risolvere ricorsivamente
|
|
sotto-assiemi/parti (`RisolviAlberoComponenti`), copiandoli anch'essi in `raw/`. Usa
|
|
`AsmRecordReader` (parser esatto dei record binari, `docs/formato-asm-record.md`) e ripiega
|
|
su `AssemblyComponentScanner` (euristica testuale, `docs/formato-asm.md`) solo se il file
|
|
non rispetta il formato validato (`InvalidDataException`). Tre punti da non confondere,
|
|
tutti imparati facendo fallire Creo (`docs/formato-asm-record.md` §7.3, §7.4 e §7.5):
|
|
i **componenti soppressi** non sono nella distinta ma il loro file serve per aprire
|
|
l'assieme (`EstraiCodiciSoppressi`, copiati senza finire fra i "non trovati"); i
|
|
**riferimenti esterni** (assembly feature, datum copiati) citano modelli che non sono né
|
|
membri né piazzamenti, e che Creo carica con tutto il loro albero
|
|
(`EstraiCodiciRiferimentiEsterni`, anche questi fuori dai "non trovati", ma con ricorsione);
|
|
e quando lo stesso codice esiste in più cartelle della share — succede per il 13% dei
|
|
codici — va copiata la copia nella **stessa cartella dell'assieme che la referenzia**
|
|
(`ScegliPerCartella`), perché il `.asm` non registra quale usa e sbagliarla impedisce a
|
|
Creo di aprire l'assieme.
|
|
5. **Verifica completezza** — mostra i `.asm` della distinta già in `raw/`, trascinabili su
|
|
Creo per l'esportazione STEP (Distributed Batch, manuale, fuori dall'app); "Verifica
|
|
completezza assiemi" controlla ricorsivamente sull'indice (non su `raw/`, stessa
|
|
`AsmRecordReader`/fallback della fase 4) se tutti i sotto-componenti di ogni assieme sono
|
|
presenti.
|
|
|
|
## Script standalone (`scripts/`)
|
|
|
|
`scripts/` contiene C# file-based apps (.NET 10, `dotnet run scripts/Nome.cs -- arg1 arg2`,
|
|
lanciati dalla root del repo — **non** da dentro `PrepStep/`, che ha un `.csproj` `WinExe`:
|
|
`dotnet run` lì avvia la GUI vera invece dello script). Elenco e dettaglio di ciascuno in
|
|
`docs/architettura.md`.
|
|
|
|
Il pattern da preservare: gli script referenziano `PrepStep/PrepStep.csproj` via `#:project`
|
|
invece di duplicare la logica di lettura dei `.asm`, che vive **solo** nel progetto
|
|
principale — un'unica fonte di verità condivisa da GUI e script. Due famiglie distinte, non
|
|
intercambiabili:
|
|
|
|
- `ExtractCreoStrings.cs`/`BomViaDb.cs` usano `AssemblyComponentScanner` (euristica testuale,
|
|
`docs/formato-asm.md`) e risolvono i sottoassiemi contro `cad_index.db`.
|
|
- `CreoBom.cs` usa `AsmRecordReader` (parser esatto dei record binari,
|
|
`docs/formato-asm-record.md`, condiviso con la GUI in fase 4/5) e risolve i sottoassiemi
|
|
cercandoli in cartelle locali (`-p`), non contro `cad_index.db`.
|