romfast/flora2roa
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Documentatie: fluxul SVN + git aliniat la procesul comun ROA

Browse Source 
flux_git_flora2roa.md era doar despre ce urmareste fiecare sistem si avea un TODO blocant
pentru un repo gitea care intre timp exista. Preia procesul din COMUN\docs\fluxul_svn_git.md:
cine aproba, cand se cere aprobarea, diff ca fisier, svn commit tintit pe binar si niciodata
pe .sc2, roa_sync doar la intrarea in proiect si imediat dupa svn commit, interdictia de
git pull. Particularitatile locale raman marcate ca atare, inclusiv pasul in plus
recompileaza_binare.ps1, care nu exista in fluxul comun.

depanare_testare_flora2roa.md trimitea inca la fluxul cu cache extern _textcache\; editarea
se face de mult in arbore.

Handoff-urile de lucru (docs\handoff_*.md) raman doar pe disc, ca si patch-urile de review.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PmUPGiStqNKSu4wWq2y77Q
This commit is contained in:
Marius Mutu
2026-08-21 21:22:44 +03:00
parent 4c9b6cbddb
commit f2c085dd6c
4 changed files with 162 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -102,6 +102,7 @@ _textcache/
.svn/ .svn/
docs/diff_*.patch docs/diff_*.patch
docs/handoff_*.md
docs/local/ docs/local/
.gstack/ .gstack/
flora2roa.zip flora2roa.zip

7
CLAUDE.md
View File

@@ -31,13 +31,16 @@ livrare. Ce se incalca cel mai usor daca nu-l citesti:
- `docs\depanare_testare_flora2roa.md` - harnessul de testare headless, ce contine `Teste\`, - `docs\depanare_testare_flora2roa.md` - harnessul de testare headless, ce contine `Teste\`,
comenzile uzuale si capcanele confirmate aici. **De citit inainte de a rula sau scrie teste.** comenzile uzuale si capcanele confirmate aici. **De citit inainte de a rula sau scrie teste.**
- `docs\flux_git_flora2roa.md` - fluxul git + SVN, ce urmareste fiecare, `roa_sync.bat`. - `docs\flux_git_flora2roa.md` - fluxul SVN + git: cine e sursa de adevar, cand se cere
aprobarea, ce se comite si unde, `roa_sync.bat`. Adaptarea locala a lui
`COMUN\docs\fluxul_svn_git.md`.
## Versionare ## Versionare
**SVN** e sursa de adevar, inclusiv pentru binarele VFP. **git** urmareste versiunile TEXT **SVN** e sursa de adevar, inclusiv pentru binarele VFP. **git** urmareste versiunile TEXT
(`.sc2`, `.pj2`) generate de FoxBin2Prg in arbore, plus `.prg`, `Teste\`, `docs\`. Binarele sunt (`.sc2`, `.pj2`) generate de FoxBin2Prg in arbore, plus `.prg`, `Teste\`, `docs\`. Binarele sunt
git-ignored, ca diff-urile sa fie lizibile. La inceput de sesiune: `roa_sync.bat`. git-ignored, ca diff-urile sa fie lizibile. `roa_sync.bat` se ruleaza in exact doua momente:
la inceput de sesiune si imediat dupa `svn commit`.
`svn commit` (care atinge binarele) se face **doar cu acordul explicit al utilizatorului**. `svn commit` (care atinge binarele) se face **doar cu acordul explicit al utilizatorului**.

14
docs/depanare_testare_flora2roa.md
View File

@@ -25,7 +25,9 @@ Specific FLORA2ROA:
- `mock_amessagebox.prg` - `amessagebox` care returneaza direct valoarea butonului, ca - `mock_amessagebox.prg` - `amessagebox` care returneaza direct valoarea butonului, ca
dialogurile modale sa nu blocheze rularea headless. dialogurile modale sa nu blocheze rularea headless.
- `verifica_sintaxa.ps1` - compilare de verificare pentru toate `.prg`-urile, pe copii in TEMP. - `verifica_sintaxa.ps1` - compilare de verificare pentru toate `.prg`-urile, pe copii in TEMP.
- `text_din_bin.ps1` / `bin_din_text.ps1` - conversie `.scx`/`.vcx` <-> text (`_textcache\`). - `text_din_bin.ps1` / `bin_din_text.ps1` - conversie `.scx` <-> text, in arbore
(`frm_import.sc2` sta langa binar, nu intr-un cache extern).
- `recompileaza_binare.ps1` - `COMPILE FORM` dupa write-back, OBLIGATORIU (vezi mai jos).
- `ruleaza_teste.ps1` - ruleaza toata suita si da sumarul. - `ruleaza_teste.ps1` - ruleaza toata suita si da sumarul.
- `test_frm_import_ui.prg` - smoke: formularul real porneste, Init completeaza intervalul din - `test_frm_import_ui.prg` - smoke: formularul real porneste, Init completeaza intervalul din
`settings.ini`, `Trace` scrie in `edtInfo`. `settings.ini`, `Trace` scrie in `edtInfo`.
@@ -68,12 +70,12 @@ capturi in `Teste\screenshots\`, erori runtime in `Teste\_erori_test.txt`.
## Editarea formularului pe text ## Editarea formularului pe text
```powershell ```powershell
powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1 # binar -> _textcache\*.sc2 powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1 # binar -> frm_import.sc2
# editezi _textcache\frm_import.sc2 BYTE-SAFE, in Windows-1252: # editezi frm_import.sc2 BYTE-SAFE, in Windows-1252:
# $t = [IO.File]::ReadAllText($p, [Text.Encoding]::GetEncoding(1252)) # $t = [IO.File]::ReadAllText($p, [Text.Encoding]::GetEncoding(1252))
# [IO.File]::WriteAllText($p, $t, [Text.Encoding]::GetEncoding(1252)) # [IO.File]::WriteAllText($p, $t, [Text.Encoding]::GetEncoding(1252))
powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile _textcache\frm_import.sc2 -DryRun powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile frm_import.sc2 -DryRun
powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile _textcache\frm_import.sc2 powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile frm_import.sc2
powershell -ExecutionPolicy Bypass -File Teste\recompileaza_binare.ps1 # OBLIGATORIU dupa write-back powershell -ExecutionPolicy Bypass -File Teste\recompileaza_binare.ps1 # OBLIGATORIU dupa write-back
``` ```
@@ -85,6 +87,8 @@ powershell -ExecutionPolicy Bypass -File Teste\recompileaza_binare.ps1 # OBLIG
Write-back-ul face fidelity check (bin -> text, comparat pe octeti) inainte de a atinge Write-back-ul face fidelity check (bin -> text, comparat pe octeti) inainte de a atinge
binarul si refuza daca `frm_import.scx` e blocat de IDE sau de `flora2roa.exe`. binarul si refuza daca `frm_import.scx` e blocat de IDE sau de `flora2roa.exe`.
Cand si ce se comite dupa write-back: `docs\flux_git_flora2roa.md`.
## Un test nou in 5 pasi ## Un test nou in 5 pasi
1. `SET SAFETY OFF` + `SET TALK OFF` ca PRIMA linie, apoi `PUBLIC gcUILog, gcSyncDir`. 1. `SET SAFETY OFF` + `SET TALK OFF` ca PRIMA linie, apoi `PUBLIC gcUILog, gcSyncDir`.

200
docs/flux_git_flora2roa.md
View File

@@ -1,79 +1,173 @@
# Flux git + SVN in FLORA2ROA # Flux SVN + git in FLORA2ROA
Proiectul e urmarit in PARALEL de doua sisteme, cu roluri diferite: Adaptarea locala a procesului comun ROA din `D:\ROA\ROACONT\COMUN\docs\fluxul_svn_git.md`.
Acolo e originalul; aici sunt doar particularitatile acestui proiect. Metoda de editare pe text:
`COMUN\docs\flux-editare-vfp-text.md`.
- **SVN** (`http://svnroa:3001/svn/ROAIMPORT/FLORA2ROA`) ramane **sursa de adevar**, inclusiv **SVN e sursa de adevar. git e oglinda.** Binarele VFP (`frm_import.scx/.sct`, `flora2roa.pjx/.pjt`,
pentru binarele VFP (`frm_import.scx/.sct`, `flora2roa.pjx/.pjt`, `.fll`, `.exe`). `.fll`, `.exe`) traiesc doar in SVN; git urmareste versiunile TEXT (`.sc2`, `.pj2`) generate in
- **git** urmareste **versiunile TEXT** ale binarelor (`.sc2`, `.pj2`), generate in arbore de arbore de FoxBin2Prg, plus `.prg`, `Teste\`, `docs\`.
FoxBin2Prg, plus sursele `.prg`, scripturile de test si documentatia. Binarele VFP sunt
git-ignored, ca diff-urile sa fie lizibile.
Metoda generala si procedura de inrolare: `D:\ROA\ROACONT\COMUN\docs\inrolare-proiect-git-text.md` - SVN: `http://svnroa:3001/svn/ROAIMPORT/FLORA2ROA`
si `fluxul_svn_git.md`. - git: `git@gitea.romfast.ro:romfast/flora2roa.git` (remote `origin`, branch `main`)
## Utilizatorul doar aproba
Comenzile le rulezi **tu**: `roa_sync.bat`, `svn commit`, `roa_sync.bat`. El nu tine minte niciun
pas si nu tasteaza nimic - dar **nimic nu se comite fara un "da" explicit de la el.**
Deci nu te opri tacut dupa ce livrezi diff-ul. **Intreaba**, cu fisierele si mesajul propuse.
## Fluxul
```
.prg / .md / .ps1 / .sql .sc2 / .pj2
| |
| bin_din_text.ps1 <- IMEDIAT
| |
| recompileaza_binare.ps1
| |
| verifica pe BINAR
+--------------------+------------------+
|
antet la zi + test rulat
|
diff ca fisier in docs\
|
INTREBI: fisiere + mesaj --> "da" ? --nu--> stop
| da
svn commit TINTIT (.prg | .scx + .SCT -- niciodata .sc2)
|
roa_sync.bat --> main: sync SVN rN
```
## Particularitatea acestui proiect ## Particularitatea acestui proiect
FLORA2ROA **nu are folder `COMUN\`** (spre deosebire de ROACONT/ROAGEST/ROAFACTURARE, unde FLORA2ROA **nu are folder `COMUN\`** (spre deosebire de ROACONT/ROAGEST/ROAFACTURARE, unde COMUN e
COMUN e un external SVN cu repo git propriu). Foloseste doar un `comun.h` local. Prin urmare: un external SVN cu repo git propriu). Foloseste doar un `comun.h` local. Prin urmare:
- nu exista `COMUN\.git` de sincronizat aici; repo-ul `romfast/comun.git` e gestionat din - nu exista `COMUN\.git` de sincronizat aici; repo-ul `romfast/comun.git` e gestionat din
proiectele care il contin efectiv; proiectele care il contin efectiv;
- scriptul partajat `COMUN\scripts\roa_sync.ps1` nu ajunge in acest proiect prin svn update, - scriptul partajat `COMUN\scripts\roa_sync.ps1` nu ajunge aici prin `svn update`, deci exista
deci exista un echivalent local: `Teste\roa_sync.ps1`, apelat de `roa_sync.bat` din radacina. un echivalent local: `Teste\roa_sync.ps1`, apelat de `roa_sync.bat` din radacina. Face aceiasi
pasi, minus repo-ul COMUN si minus inchiderea automata a branch-urilor `claude/*`;
- scripturile de conversie au nume locale: `Teste\text_din_bin.ps1` (= `git_sync.ps1`) si
`Teste\bin_din_text.ps1` (= `txt2vcx.ps1`);
- **in plus fata de fluxul comun**, dupa fiecare write-back e OBLIGATORIU
`Teste\recompileaza_binare.ps1`: write-back-ul reface `.scx/.SCT` fara cod obiect, deci
formularul ruleaza fara `#INCLUDE "comun.h"` si constantele (`CT_SUCCES`) crapa in RUNTIME,
desi verificarea de sintaxa trece;
- fiind repo de proiect, nu COMUN, **branch-urile si commit-urile git pe `main` sunt permise**.
Ce e restrictionat e doar **push-ul automat**: `roa_sync` publica singur numai commit-urile
`sync SVN rN`; orice commit non-sync nepushed blocheaza push-ul si apare ca avertisment, ca
sa treaca intai prin review.
## La inceput de sesiune ## Cazuri
``` **Intri in proiect** -> rulezi `roa_sync.bat`, fara sa intrebi, daca `svn status` si `git status`
roa_sync.bat sunt curate. Daca nu sunt, intrebi intai - pot fi modificari nefinalizate ale altcuiva.
**Ai editat `.prg` / `.md` / `.ps1` / `.sql`** -> antetul la zi, testul rulat
(`Teste\verifica_sintaxa.ps1` dupa orice `.prg`), diff-ul ca fisier in `docs\`.
**Ai editat `.sc2`** -> `bin_din_text.ps1` **imediat**, apoi `recompileaza_binare.ps1`, apoi
verifici pe binar (reconvertesti binarul intr-un folder temporar si compari cu textul din arbore;
mtime nu dovedeste nimic). Text fara write-back = modificarea nu exista. Abia apoi antet / test /
diff.
**Vrei sa-ti tii munca in git** -> branch, liber (`claude/<subiect>` e conventia). Fiind repo de
proiect, merge-ul in `main` la final e normal.
**Esti pe branch si te bate gandul la `roa_sync`** -> **nu.** `roa_sync` se ruleaza in exact doua
momente: la **intrarea** in proiect si **imediat dupa `svn commit`**. Ce te incurca e `svn update`
de la pasul 1, nu git-ul:
- **branch cu modificari necomise** -> `svn update` ruleaza neconditionat si aduce binare noi peste
ce ai pe disc; la conflict `roa_sync` se opreste cu eroare;
- **branch cu tree curat** -> ramai cu text de pe `main` peste binare de pe branch, iar VFP ar
compila altceva.
Daca chiar trebuie sa aduci ceva de la altii in mijlocul lucrului: termina write-back-ul, da
`svn commit` daca lucrarea e gata, si abia apoi `roa_sync`.
**Vrei sa aduci ce au facut altii** -> `roa_sync.bat`. **Niciodata `git pull`**: git poarta doar
textele, nu si binarele. Un `pull` ti-ar da `.sc2`-ul nou peste un `.scx/.SCT` vechi - VFP
compileaza binarul, deci modificarea n-ar exista in aplicatie, iar urmatorul `text_din_bin` ar
regenera textul din binarul vechi si ar sterge-o. `roa_sync` face ordinea corecta: `svn update`
(binare + surse) -> regenerare text -> git prin fast-forward.
**Vrei `svn update`** -> doar din stare curata. Niciodata in mijlocul lucrului. Daca ai text `.sc2`
editat fara write-back, fa intai write-back-ul.
**`svn update` a dat conflict** -> opreste-te si raporteaza. Binarele nu se rezolva manual.
**Dupa `svn update`, git arata fisiere modificate** -> e oglinda ramasa in urma, nu munca ta.
Nu le comite de mana; le ia `roa_sync` intr-un `sync SVN rN`.
**Diff-ul e gata** -> ceri aprobarea, explicit si complet: lista fisierelor de comis si mesajul
propus. Nu presupune "da" din tacere si nu amana intrebarea pentru "mai tarziu" - el nu tine minte
pasul, tu il tii.
**A zis "da"** -> rulezi tu `svn commit` **tintit**, doar fisierele aprobate - pe binar
(`frm_import.scx` + `frm_import.SCT`), niciodata pe `.sc2`. Niciodata pe tot proiectul: intra
zgomotul de compilare VFP. Imediat dupa, rulezi `roa_sync.bat`. Raportezi revizia SVN si ce a
intrat pe `main`.
**A zis "nu" sau a cerut modificari** -> nu comiti, nu insisti, nu rulezi `roa_sync`. Lucrarea
ramane necomisa pe disc si o raportezi ca atare la predarea contextului.
**Predai contextul** -> raporteaza explicit daca ai lasat text `.sc2` editat fara write-back sau
write-back fara recompilare. Amandoua sunt stari periculoase.
## Interzis
- `git pull` - aduce textele fara binare; se foloseste `roa_sync.bat`
- `svn commit` pe tot proiectul sau pe `.sc2`
- write-back pe `.pj2` - nu e suportat; acolo textul se citeste, modificarea se face in IDE
- `svn commit` fara acordul explicit al utilizatorului (atinge binarele)
## Comenzi
```powershell
roa_sync.bat # inceput de sesiune si dupa svn commit
powershell -File Teste\roa_sync.ps1 -GitOnly # verificare rapida, fara SVN
powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1 # binar -> frm_import.sc2
powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile frm_import.sc2 -DryRun
powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile frm_import.sc2
powershell -ExecutionPolicy Bypass -File Teste\recompileaza_binare.ps1 # OBLIGATORIU dupa write-back
``` ```
Face, in ordine: `svn update` -> regenerarea textelor `.??2` (git_sync) -> commit `sync SVN r<rev>` Textul `.sc2` se editeaza **byte-safe, in Windows-1252** (vezi
pe `main` -> reconciliere cu `origin` -> push (doar commit-uri de sync; unul non-sync blocheaza `COMUN\docs\conventie_encoding_cp1252.md`):
push-ul automat, ca sa treaca prin review).
Verificare rapida fara SVN: `powershell -File Teste\roa_sync.ps1 -GitOnly`. ```powershell
$t = [IO.File]::ReadAllText($p, [Text.Encoding]::GetEncoding(1252))
[IO.File]::WriteAllText($p, $t, [Text.Encoding]::GetEncoding(1252))
```
Regula de push, verificata pe un remote local de test: un commit `sync SVN` se publica Write-back-ul face fidelity check pe octeti inainte de a atinge binarul. Dupa el, binarul apare
automat, iar orice commit non-sync nepushed **blocheaza** push-ul automat si apare ca modificat in SVN.
avertisment, ca sa treaca intai prin review.
## Ce urmareste git ## Ce urmareste git
Urmarite: `.prg`, `.h`, `.sc2`/`.pj2` (textele binarelor), `Teste\`, `docs\`, `settings.ini`, Urmarite: `.prg`, `.h`, `.sc2`/`.pj2` (textele binarelor), `Teste\`, `docs\`, `settings.ini`,
`settings.flora.ini`, `app.ico`, `.fll` (dependente de rulare, versionate si in SVN), `settings.flora.ini`, `app.ico`, `.fll` (dependente de rulare, versionate si in SVN), exemplele
exemplele mici de import care sunt si in SVN. mici de import care sunt si in SVN.
Ignorate (`.gitignore`): binarele convertibile (`.scx/.sct/.pjx/.pjt/...`), compilatele Ignorate (`.gitignore`): binarele convertibile (`.scx/.sct/.pjx/.pjt/...`), compilatele (`.fxp`),
(`.fxp`), `flora2roa.exe`, `log\`, artefactele testelor (`Teste\uisync`, `Teste\screenshots`, `flora2roa.exe`, `log\`, artefactele testelor (`Teste\uisync`, `Teste\screenshots`, `*_log.txt`),
`*_log.txt`), si restul folderului `EXEMPLE\` (~900 fisiere, ~80 MB de date locale de lucru; patch-urile de review (`docs\diff_*.patch`), si restul folderului `EXEMPLE\` (~900 fisiere, ~80 MB
in git raman doar cele 7 exemple versionate si in SVN). de date locale de lucru; in git raman doar cele 7 exemple versionate si in SVN).
`.gitattributes` are `* -text`: SVN ramane autoritatea pentru sfarsiturile de linie, git nu `.gitattributes` are `* -text`: SVN ramane autoritatea pentru sfarsiturile de linie, git nu
normalizeaza nimic (altfel ar aparea modificari fantoma dupa fiecare `svn update`). normalizeaza nimic (altfel ar aparea modificari fantoma dupa fiecare `svn update`).
Simetric, `svn:ignore` pe radacina acopera `.git`, `.gitignore`, `.gitattributes` si toate Simetric, `svn:ignore` pe radacina acopera `.git`, `.gitignore`, `.gitattributes` si toate textele
textele `.??2`, ca sa nu ajunga din greseala in SVN. `.??2`, ca sa nu ajunga din greseala in SVN.
## Editarea formularului pe text ## Copii ramase in urma
```powershell Nimic nu se sincronizeaza in fundal. O copie neatinsa de luni se aliniaza singura la primul
powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1 # binar -> frm_import.sc2 `roa_sync.bat` rulat de acolo: `svn update` -> regenerare text -> `sync SVN rN` -> fetch -> ff sau
# editezi frm_import.sc2 byte-safe, in Windows-1252 (vezi conventie_encoding_cp1252.md) `rebase --empty=drop`, care arunca automat sync-urile al caror continut e deja pe origin.
powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile frm_import.sc2 -DryRun
powershell -ExecutionPolicy Bypass -File Teste\bin_din_text.ps1 -TextFile frm_import.sc2
```
Write-back-ul face fidelity check pe octeti inainte de a atinge binarul. Dupa el, binarul apare
modificat in SVN: **`svn commit` doar cu acordul explicit al utilizatorului**.
## De facut (blocant, cere interventia utilizatorului)
Repo-ul gitea `romfast/flora2roa.git` **nu exista inca**; procedura interzice crearea de
repo-uri prin API. Dupa ce e creat din interfata gitea:
```powershell
git -C D:\PROIECTE\FLORA\FLORA2ROA remote add origin git@gitea.romfast.ro:romfast/flora2roa.git
git -C D:\PROIECTE\FLORA\FLORA2ROA push -u origin main
```
Pana atunci repo-ul e valid local, iar `roa_sync.bat` semnaleaza lipsa remote-ului si continua.