Documentatie: fluxul SVN + git aliniat la procesul comun ROA

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
2026-08-21 21:22:44 +03:00
parent 4c9b6cbddb
commit f2c085dd6c
4 changed files with 162 additions and 60 deletions
--- a/docs/depanare_testare_flora2roa.md
+++ b/docs/depanare_testare_flora2roa.md
@@ -25,7 +25,9 @@ Specific FLORA2ROA:
 - `mock_amessagebox.prg` - `amessagebox` care returneaza direct valoarea butonului, ca
  dialogurile modale sa nu blocheze rularea headless.
 - `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.
 - `test_frm_import_ui.prg` - smoke: formularul real porneste, Init completeaza intervalul din
  `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

 ```powershell
-powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1          # binar -> _textcache\*.sc2
-# editezi _textcache\frm_import.sc2 BYTE-SAFE, in Windows-1252:
+powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1          # binar -> frm_import.sc2
+# editezi frm_import.sc2 BYTE-SAFE, in Windows-1252:
 #   $t = [IO.File]::ReadAllText($p, [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 _textcache\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
 ```

@@ -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
 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

 1. `SET SAFETY OFF` + `SET TALK OFF` ca PRIMA linie, apoi `PUBLIC gcUILog, gcSyncDir`.
--- a/docs/flux_git_flora2roa.md
+++ b/docs/flux_git_flora2roa.md
@@ -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
-  pentru binarele VFP (`frm_import.scx/.sct`, `flora2roa.pjx/.pjt`, `.fll`, `.exe`).
- **git** urmareste **versiunile TEXT** ale binarelor (`.sc2`, `.pj2`), generate in arbore de
-  FoxBin2Prg, plus sursele `.prg`, scripturile de test si documentatia. Binarele VFP sunt
-  git-ignored, ca diff-urile sa fie lizibile.
+**SVN e sursa de adevar. git e oglinda.** Binarele VFP (`frm_import.scx/.sct`, `flora2roa.pjx/.pjt`,
+`.fll`, `.exe`) traiesc doar in SVN; git urmareste versiunile TEXT (`.sc2`, `.pj2`) generate in
+arbore de FoxBin2Prg, plus `.prg`, `Teste\`, `docs\`.

-Metoda generala si procedura de inrolare: `D:\ROA\ROACONT\COMUN\docs\inrolare-proiect-git-text.md`
-si `fluxul_svn_git.md`.
+- SVN: `http://svnroa:3001/svn/ROAIMPORT/FLORA2ROA`
+- 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

-FLORA2ROA **nu are folder `COMUN\`** (spre deosebire de ROACONT/ROAGEST/ROAFACTURARE, unde
-COMUN e un external SVN cu repo git propriu). Foloseste doar un `comun.h` local. Prin urmare:
+FLORA2ROA **nu are folder `COMUN\`** (spre deosebire de ROACONT/ROAGEST/ROAFACTURARE, unde COMUN e
+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
  proiectele care il contin efectiv;
- scriptul partajat `COMUN\scripts\roa_sync.ps1` nu ajunge in acest proiect prin svn update,
-  deci exista un echivalent local: `Teste\roa_sync.ps1`, apelat de `roa_sync.bat` din radacina.
+- scriptul partajat `COMUN\scripts\roa_sync.ps1` nu ajunge aici prin `svn update`, deci exista
+  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

-```
-roa_sync.bat
+**Intri in proiect** -> rulezi `roa_sync.bat`, fara sa intrebi, daca `svn status` si `git status`
+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>`
-pe `main` -> reconciliere cu `origin` -> push (doar commit-uri de sync; unul non-sync blocheaza
-push-ul automat, ca sa treaca prin review).
+Textul `.sc2` se editeaza **byte-safe, in Windows-1252** (vezi
+`COMUN\docs\conventie_encoding_cp1252.md`):

-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
-automat, iar orice commit non-sync nepushed **blocheaza** push-ul automat si apare ca
-avertisment, ca sa treaca intai prin review.
+Write-back-ul face fidelity check pe octeti inainte de a atinge binarul. Dupa el, binarul apare
+modificat in SVN.

 ## Ce urmareste git

 Urmarite: `.prg`, `.h`, `.sc2`/`.pj2` (textele binarelor), `Teste\`, `docs\`, `settings.ini`,
-`settings.flora.ini`, `app.ico`, `.fll` (dependente de rulare, versionate si in SVN),
-exemplele mici de import care sunt si in SVN.
+`settings.flora.ini`, `app.ico`, `.fll` (dependente de rulare, versionate si in SVN), exemplele
+mici de import care sunt si in SVN.

-Ignorate (`.gitignore`): binarele convertibile (`.scx/.sct/.pjx/.pjt/...`), compilatele
-(`.fxp`), `flora2roa.exe`, `log\`, artefactele testelor (`Teste\uisync`, `Teste\screenshots`,
-`*_log.txt`), si restul folderului `EXEMPLE\` (~900 fisiere, ~80 MB de date locale de lucru;
-in git raman doar cele 7 exemple versionate si in SVN).
+Ignorate (`.gitignore`): binarele convertibile (`.scx/.sct/.pjx/.pjt/...`), compilatele (`.fxp`),
+`flora2roa.exe`, `log\`, artefactele testelor (`Teste\uisync`, `Teste\screenshots`, `*_log.txt`),
+patch-urile de review (`docs\diff_*.patch`), si restul folderului `EXEMPLE\` (~900 fisiere, ~80 MB
+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
 normalizeaza nimic (altfel ar aparea modificari fantoma dupa fiecare `svn update`).

-Simetric, `svn:ignore` pe radacina acopera `.git`, `.gitignore`, `.gitattributes` si toate
-textele `.??2`, ca sa nu ajunga din greseala in SVN.
+Simetric, `svn:ignore` pe radacina acopera `.git`, `.gitignore`, `.gitattributes` si toate textele
+`.??2`, ca sa nu ajunga din greseala in SVN.

-## Editarea formularului pe text
+## Copii ramase in urma

-```powershell
-powershell -ExecutionPolicy Bypass -File Teste\text_din_bin.ps1      # binar -> frm_import.sc2
-# editezi frm_import.sc2 byte-safe, in Windows-1252 (vezi conventie_encoding_cp1252.md)
-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.
+Nimic nu se sincronizeaza in fundal. O copie neatinsa de luni se aliniaza singura la primul
+`roa_sync.bat` rulat de acolo: `svn update` -> regenerare text -> `sync SVN rN` -> fetch -> ff sau
+`rebase --empty=drop`, care arunca automat sync-urile al caror continut e deja pe origin.