Come disattivare il formattatore del codice Eclipse per alcune sezioni del codice Java?

Ho del codice Java con istruzioni SQL scritte come stringhe Java (per favore niente OR / M flamewars, l'SQL incorporato è quello che è - non la mia decisione).

Ho diviso semanticamente le istruzioni SQL in più stringhe concatenate su più righe di codice per facilità di manutenzione. Quindi invece di qualcosa come:

String query = "SELECT FOO, BAR, BAZ FROM ABC WHERE BAR > 4";

Ho qualcosa del tipo:

String query =
    "SELECT FOO, BAR, BAZ" +
    "  FROM ABC          " +
    " WHERE BAR > 4      ";

Questo stile rende l'SQL molto più facile da leggere e gestire (IMHO), specialmente per query più grandi. Ad esempio, posso mettere il mio editor in modalità "sovrascrivi" e modificare il testo sul posto abbastanza facilmente.

Si noti che questo problema si generalizza oltre l'esempio particolare di SQL. Qualsiasi codice scritto con qualsiasi formattazione verticale, in particolare costrutti tabulari, è suscettibile alla distruzione da parte di una bella stampante.

Ora, alcuni membri del progetto usano l'editor Eclipse e la formattazione semantica viene spesso distrutta quando formattano un intero file sorgente.

C'è un modo per istruire Eclipse a ignorare determinate righe di sorgente rispetto alla formattazione?

Sto cercando qualcosa di simile a un commento speciale che commuta il formattatore Eclipse. Idealmente, un tale commento potrebbe essere configurabile per essere quello che scegliamo e altri formattatori potrebbero essere programmati per rispettarlo:

// STOP-ECLIPSE-FORMATTING
String query =
    "SELECT FOO, BAR, BAZ" +
    "  FROM ABC          " +
    " WHERE BAR > 4      ";
// START-ECLIPSE-FORMATTING

Ovviamente, una "soluzione" è quella di far standardizzare i membri del nostro team su alcuni formattatori esterni come Jalopy o JIndent , ma non è questo il problema (anche la mia decisione su questo progetto): sto specificatamente cercando un modo per evitare il formatter di Eclipse su una base ad hoc.

Idealmente, una soluzione mi consentirà di inserire le istruzioni per il formattatore Eclipse senza richiedere ai membri del team che utilizzano Eclipse di eseguire alcuna riconfigurazione IDE (oltre alla possibilità di scegliere un commento al comando agnostico del formatter: STOP-ECLIPSE-FORMATTING→ STOP-FORMATTING).

Eclipse 3.6 consente di disattivare la formattazione inserendo un commento speciale, ad esempio

// @formatter:off
...
// @formatter:on

Le funzioni on / off devono essere impostato su "on" nelle preferenze Eclipse: Java > Code Style > Formatter. Clicca su Edit, Off/On Tags, abilitare Enable Off/On tags.

È anche possibile cambiare le stringhe magiche nelle preferenze - dai un'occhiata ai documenti di Eclipse 3.6 qui .

Maggiori informazioni

Java > Code Style > Formatter > Edit > Off/On Tags

Questa preferenza consente di definire un tag da disabilitare e un tag per abilitare il formatter (vedere la scheda Off / On Tag nel profilo del formatter):

È inoltre necessario abilitare i flag da Java Formatting

AFAIK di Eclipse 3.5 M4 sul formatter ha un'opzione "Never Join Lines" che preserva le interruzioni delle linee dell'utente. Forse fa quello che vuoi.

Altrimenti c'è questo brutto hack

String query = //
    "SELECT FOO, BAR, BAZ" + //
    "  FROM ABC"           + //
    " WHERE BAR > 4";

Vedi questa risposta su SO .

Esiste un'altra soluzione che è possibile utilizzare per sopprimere la formattazione di commenti di blocco specifici. Utilizzare /*-(notare il trattino) all'inizio del commento sul blocco e la formattazione non sarà influenzata se si formatta il resto del file.

/*-
 * Here is a block comment with some very special
 * formatting that I want indent(1) to ignore.
 *
 *    one
 *        two
 *            three
 */

Fonte: documentazione su Oracle .

Invece di disattivare la formattazione, è possibile configurarlo per non unire le linee già tratteggiate. Simile alla risposta di Jitter, ecco Eclipse STS:

Proprietà → Stile codice Java → Formatter → Abilita impostazioni specifiche del progetto OPPURE Configura impostazioni dell'area di lavoro → Modifica → A capo (scheda) → seleziona "Non unire mai le linee già tratteggiate"

Salva, applica.

Devi attivare la possibilità di aggiungere i tag formatter. Nella barra dei menu vai a:

Windows → Preferences Java → Code Style → Formatter

Premi il Editpulsante. Scegli l'ultima scheda. Notare la casella On / Off e abilitarli con una casella di controllo.

Se metti il ​​segno più all'inizio della riga, formatta diversamente:

String query = 
    "SELECT FOO, BAR, BAZ" 
    +    "  FROM ABC"           
    +    " WHERE BAR > 4";

Sto usando parti di stringa a larghezza fissa (riempite con spazi bianchi) per evitare che il formatter rovini il mio rientro di stringa SQL. Questo ti dà risultati contrastanti e non funzionerà dove gli spazi bianchi non vengono ignorati come in SQL, ma possono essere utili.

    final String sql = "SELECT v.value FROM properties p               "
            + "JOIN property_values v ON p.property_id = v.property_id "
            + "WHERE p.product_id = ?                                  "
            + "AND v.value        IS NOT NULL                          ";

Termina ciascuna riga con una doppia barra "//". Ciò impedirà all'eclissi di spostarli tutti sulla stessa linea.

Metodo alternativo: in Eclipse 3.6, in "Disposizione linea", quindi in "Impostazioni generali" è disponibile l'opzione "Non unire mai le linee già tratteggiate". Ciò significa che il formatter avvolgerà le linee lunghe ma non annullerà alcun avvolgimento che hai già.

@xpmatteo ha la risposta alla disabilitazione di porzioni di codice, ma in aggiunta a ciò, le impostazioni di eclissi predefinite dovrebbero essere impostate per formattare solo le righe di codice modificate anziché l'intero file.

Preferences->Java->Editor->Save Actions->Format Source Code->Format Edited Lines

Ciò avrebbe impedito che ciò accadesse in primo luogo poiché i tuoi colleghi stanno riformattando il codice che non hanno effettivamente cambiato. Questa è una buona pratica per evitare svantaggi che rendono inutile la diff sul controllo del codice sorgente (quando un intero file viene riformattato a causa di differenze minori nelle impostazioni del formato).

Impedirebbe anche la riformattazione se l'opzione tag on / off fosse disattivata.

I commenti fantasma, aggiungendo //dove vuoi nuove righe, sono fantastici!

1. @Formatter: off aggiunge un riferimento dal codice all'editor. A mio avviso, il codice non dovrebbe mai avere tali riferimenti.

2. I commenti fantasma (//) funzioneranno indipendentemente dallo strumento di formattazione utilizzato. Indipendentemente da Eclipse o InteliJ o qualsiasi editor tu usi. Funziona anche con il bellissimo formato Java di Google

3. I commenti fantasma (//) funzioneranno su tutta l'applicazione. Se hai anche Javascript e forse usi qualcosa come JSBeautifier . Puoi avere uno stile di codice simile anche nel Javascript.

4. In realtà, probabilmente vuoi la formattazione giusta? Vuoi rimuovere tab / spazio misto e spazi finali. Vuoi rientrare le righe in base allo standard del codice. Quello che NON vuoi è una lunga fila. Questo, e solo quello, è ciò che ti dà il commento fantasma!

Questo hack funziona:

String x = "s" + //Formatter Hack
    "a" + //
    "c" + //
    "d";

Suggerirei di non usare il formatter. Il codice errato dovrebbe apparire non buono artificialmente. Un buon codice richiede tempo. Non puoi tradire la qualità. La formattazione fa parte della qualità del codice sorgente.