Devo modificare lo spazio bianco di un codebase per conformarmi a uno stile di codifica? [duplicare]

5

Abbiamo un grande progetto Java (1m + SLOC) con spazi bianchi misti - alcuni file hanno schede e altri hanno spazi. È complicato far funzionare il mio editor con qualsiasi file che stia modificando.

Sceglieremo una convenzione e la applicheremo in futuro. La questione è se dovrei fare un commit per correggere lo spazio bianco in tutto il progetto dopo che è stata presa la decisione.

Git può ignorare le modifiche in spazi vuoti, quindi in futuro per confrontare con revisioni precedenti dovremmo usare git diff -w . Tuttavia, se e quando aggiorniamo un file in modo frammentario, dovremmo comunque utilizzare git diff -w .

Per la cronaca, questo è un progetto Eclipse RCP, quindi usare un IDE diverso da Eclipse non è molto sensato.

Modifica: ci sono alcune buone risposte qui, ma tendono a discutere su come dovrei andare su questo piuttosto che se questa è una buona idea o se dovrei semplicemente lasciarla bene da sola , che è quello che mi interessa davvero.

    
posta wrgrs 22.04.2015 - 14:24
fonte

4 risposte

16

Cosa intendi con "il mio editor"? E cosa intendi con "git -w"? Stai usando un editor e strumenti da riga di comando al posto di un IDE? Posso consigliare IntelliJ IDEA? È il miglior IDE mai di java, e non ha alcun problema con nessuno dei due tipi di spazi bianchi, o anche con spazi bianchi misti all'interno dello stesso file.

In genere, se una modifica di grandi dimensioni ha viene apportata al codice base, come la modifica della formattazione, dovrebbe essere eseguita tutto in una volta e il prima possibile.

Se non lo fai, i file continueranno a essere impegnati in futuro senza alcun motivo diverso dalle modifiche dello spazio bianco, inutilmente gonfiando gli elenchi della cronologia e obbligandoti a richiedere spesso diff di file solo per dirti "i file differiscono solo negli spazi bianchi ".

Inoltre, non sarà mai ovvio se un file è stato commesso a causa di modifiche effettive o solo a causa di cambiamenti di spazi bianchi, quindi se due o più sviluppatori hanno sbocchi spazio e / o formattazione diversi per errore, ci vorranno alcuni tempo e diversi commit in cui uno sviluppatore sta annullando le modifiche degli spazi bianchi di un altro fino a quando non ci si rende conto che questa discrepanza esiste.

Riformattando e commettendo tutto in una volta, il numero di revisione di quel commit (che da quel giorno in poi sarà conosciuto come "The Great Big Reformatting") verrà memorizzato da tutti, quindi ogni volta che vedi quel numero di revisione lo saprai per non richiedere nemmeno un diff.

Inoltre, da quel momento in poi, tutti sapranno che i successivi commit dovuti a cambiamenti di spazi bianchi dovrebbero essere non fatti, perché sono ovviamente il risultato di una mancata corrispondenza tra gli sviluppatori.

Emendamento

Ora, sulla questione di se dovresti convertire l'intero codice base per conformarsi a uno stile di codifica particolare, non è una cosa facile rispondere senza conoscere i particolari della tua situazione. La risposta ovvia, che chiunque là fuori ti dirà, è che uno stile di codifica coerente è importante, e che anche uno cattivo (qualunque sia lo standard) ma uno stile coerente è migliore di uno stile incoerente . Tuttavia, ci sono alcune domande pratiche da porre per prime:

  • La maggior parte dei contributori importanti sul posto di lavoro è d'accordo?

  • Ci sono dei contributori che, pur essendo una minoranza, potrebbero smettere di andarsene se procederai con questo? E quanto sono importanti?

  • Quanto è grande una varietà di stili? Si tratta solo di schede vs spazi o include altri aspetti importanti dello stile di codifica come Allman vs. parentesi graffe egiziane? Le persone dovrebbero essere abbastanza flessibili da non preoccuparsi di una piccola varietà.

  • Ma soprattutto: È davvero necessario?

Voglio dire, nel mio attuale lavoro, ogni sviluppatore sta lavorando su un sottoinsieme specifico e chiaramente delineato del codice base, quindi non mi dilungo (molto) nel codice degli altri, e nessuno approfondisce il mio codice, quindi non importa che abbiamo stili molto diversi. Non mi prende in tasca né mi rompe la gamba che un collega avvolge le sue linee alla colonna 80. (Ssssh, probabilmente non sa come modificare l'impostazione pertinente.) La situazione sarebbe molto diversa se avessimo sviluppatori il cui lavoro comportava frequenti scambi con il codice di altre persone. Se si dispone di una situazione del genere e se gli stili di codifica variano così tanto da rendere difficile per loro svolgere il proprio lavoro, probabilmente si dovrebbe applicare uno stile di codifica unico per tutti. Altrimenti, forse no.

Un'ultima nota finale:

In teoria, dovrebbe essere possibile risolvere questo problema con mezzi tecnici in modo che a) diversi sviluppatori possano lavorare sullo stesso codice, e tuttavia b) ogni sviluppatore possa godere di qualsiasi stile di codifica preferisca. Il modo in cui questo sarebbe (in teoria) realizzato sarebbe avere il codice formattato secondo lo stile preferito durante l'aggiornamento dal sistema di controllo della versione, e riformattato nello "stile del progetto" subito prima del commit. Sfortunatamente, ad oggi, non ci sono strumenti che lo faranno per quanto ne so. IntelliJ IDEA si avvicina sostenendo più stili, tra cui uno "stile personale" e uno "stile di progetto", ma non è completamente automatizzato: si può ancora sfogliare il codice non modificato in "stile progetto", se si riformattano i file in il tuo "stile personale" apparirà sfortunatamente come modificato rispetto alle copie incontaminate, (che è probabilmente un difetto del sistema di controllo delle versioni e non di IDEA) e il passaggio (facoltativo ovviamente) che ri-formatta i file in lo "stile di progetto" al momento del commit lascia di nuovo tutte le copie locali in "stile progetto". Se qualcuno sa qualcosa che raggiunge più di quello, per favore dì.

    
risposta data 22.04.2015 - 14:50
fonte
9
  1. Prima ancora di iniziare il Big Format, mettere in atto processi, procedure e strumenti adeguati per garantire una formattazione coerente in futuro. Non ha senso attraversare quel dolore, se lo stesso casino uscirà comunque tra un anno.
  2. Per ridurre al minimo l'inferenza di fusione, coordinati con tutti usando l'albero dei sorgenti e imposta una data specifica quando il Big Format è in corso, dando a tutti la possibilità di unire le modifiche nella linea principale. Registra e pubblica quella data, così come il nome / numero / hash / qualunque sia il commit. Sarebbe probabilmente una buona idea anche taggare.
  3. In nessuna circostanza, non mescolare le modifiche di formattazione e non formattazione.
  4. Utilizza uno strumento automatico ben noto, ben recensito, ben testato e affidabile (un piccolo script sed , indent , il motore di formattazione di Eclipse, ...) per eseguire il Big Format e non eseguire eventuali modifiche manuali all'output di tale strumento; l'output dello strumento deve essere impegnato così com'è, e il messaggio di commit dovrebbe specificare il nome esatto, la versione, la configurazione e la riga di comando (se applicabile) per lo strumento, in modo che tutti possano riprodurre i risultati.

Quest'ultimo punto ha due vantaggi:

  • Essere in grado di riprodurre il diff significa che puoi cambiare dovendo fidarti del diff che nessuno stava cercando di introdurre un cambiamento in quella linea da 1m a dover confidare in Eclipse Foundation (per esempio) che non stanno cercando di intrufolarsi un cambiamento nel tuo codice tramite il loro motore di formattazione (che è estremamente improbabile, e potrebbe essere ulteriormente mitigato usando più strumenti diversi per finire con lo stesso diff, se possibile).
  • Essere in grado di riprodurre il diff significa che gli sviluppatori su rami non principali possono eseguire il "merge" riproducendo meccanicamente gli effetti del commit piuttosto che dover effettivamente unire le loro modifiche nel codice mainline appena formattato.
risposta data 22.04.2015 - 15:55
fonte
2

Sì, correggere tutti i file esistenti immediatamente prima di iniziare a far rispettare le regole degli spazi bianchi per i nuovi commit è una buona idea. Se hai uno spazio bianco misto, non esiste una cosa come "lasciare abbastanza bene da solo". Il tuo codebase non sta bene.

Se non lo aggiustate, diventa quasi impossibile applicare una politica di "solo spazio bianco" rispetto a "modifica solo codice". E ciò significa

  • Piccole differenze estranee ogni volta che viene apportata una modifica secondaria a un vecchio file.
  • I grossi cambiamenti di spazi bianchi nella funzione casuale vengono commessi, ogni volta che qualcuno si sente frustrato abbastanza da correggere il file in cui stanno lavorando.

Fallo e basta.

    
risposta data 22.04.2015 - 21:55
fonte
-1

No, attendi fino a quando non viene presa una decisione.

Prima del reformat suggerisco di creare un profilo di formattazione Eclipse e di distribuirlo a tutti gli sviluppatori e iniziare a usarlo. Fai in modo che Eclipse utilizzi l'azione di salvataggio per formattare automaticamente ogni salvataggio di file.

Quindi esegui una riformattazione completa e esegui il commit come un singolo refactoring.

Il codice è ora coerente e rimarrà tale.

Ma aggiungi qualche strumento di analisi alla build per verificare la corretta formattazione. Questo per cogliere errori.

    
risposta data 22.04.2015 - 19:30
fonte

Leggi altre domande sui tag