Comment désactiver le formateur de code Eclipse pour certaines sections de code Java?

J'ai du code Java avec des instructions SQL écrites sous forme de chaînes Java (s'il vous plaît pas de guerres de flamme OR / M, le SQL intégré est ce qu'il est - pas ma décision).

J'ai divisé les instructions SQL sémantiquement en plusieurs chaînes concaténées sur plusieurs lignes de code pour faciliter la maintenance. Donc, au lieu de quelque chose comme:

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

J'ai quelque chose comme:

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

Ce style rend le SQL beaucoup plus facile à lire et à maintenir (IMHO), en particulier pour les requêtes plus volumineuses. Par exemple, je peux mettre mon éditeur en mode "écraser" et modifier le texte en place assez facilement.

Notez que ce problème se généralise au-delà de l'exemple particulier de SQL. Tout code écrit avec n'importe quel format vertical, en particulier les constructions tabulaires, est susceptible d'être détruit par une jolie imprimante.

Désormais, certains membres du projet utilisent l'éditeur Eclipse et la mise en forme sémantique est souvent détruite lorsqu'ils mettent en forme un fichier source entier.

Existe-t-il un moyen de demander à Eclipse d'ignorer certaines lignes de source en ce qui concerne le formatage?

Je cherche quelque chose comme un commentaire spécial qui bascule le formateur Eclipse. Idéalement, un tel commentaire pourrait être configurable pour être celui que nous choisissons, et d'autres formateurs pourraient également être programmés pour le respecter:

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

Évidemment, une «solution» consiste à faire normaliser les membres de notre équipe sur un formateur externe comme Jalopy ou JIndent , mais ce n'est pas de cela qu'il s'agit (également, pas ma décision sur ce projet): je cherche spécifiquement un moyen de éviter le formateur Eclipse sur une base ad hoc.

Idéalement, une solution me permettra d'insérer des instructions pour le formateur Eclipse sans obliger les membres de l'équipe utilisant Eclipse à effectuer une reconfiguration IDE (autre que le choix éventuel d'un commentaire de commande agnostique du formateur: STOP-ECLIPSE-FORMATTING→ STOP-FORMATTING).

Eclipse 3.6 vous permet de désactiver la mise en forme en plaçant un commentaire spécial, comme

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

Les / désactiver les fonctions doivent être mis « sur » dans les préférences Eclipse: Java > Code Style > Formatter. Cliquez sur Edit, Off/On Tags, activez Enable Off/On tags.

Il est également possible de changer les chaînes magiques dans les préférences - consultez la documentation Eclipse 3.6 ici .

Plus d'information

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

Cette préférence vous permet de définir une balise à désactiver et une balise pour activer le formateur (voir l'onglet Balises Off / On dans votre profil de formateur):

Vous devez également activer les drapeaux de Java Formatting

AFAIK d'Eclipse 3.5 M4 sur le formateur a une option "Never Join Lines" qui préserve les sauts de lignes utilisateur. Peut-être que cela fait ce que vous voulez.

Sinon, il y a ce vilain hack

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

Voir cette réponse sur SO .

Il existe une autre solution que vous pouvez utiliser pour supprimer la mise en forme de commentaires de bloc spécifiques. Utilisez /*-(notez le trait d'union) au début du commentaire de bloc et la mise en forme ne sera pas affectée si vous formatez le reste du fichier.

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

Source: Documentation chez Oracle .

Au lieu de désactiver le formatage, vous pouvez le configurer pour ne pas joindre les lignes déjà encapsulées. Semblable à la réponse de Jitter, voici pour Eclipse STS:

Propriétés → Style de code Java → Formateur → Activer les paramètres spécifiques au projet OU Configurer les paramètres de l'espace de travail → Modifier → Habillage de ligne (onglet) → cocher "Ne jamais joindre des lignes déjà encapsulées"

Enregistrez, appliquez.

Vous devez activer la possibilité d'ajouter les balises du formateur. Dans la barre de menus, accédez à:

Windows → Preferences Java → Code Style → Formatter

Appuyez sur le Editbouton. Choisissez le dernier onglet. Remarquez la case On / Off et activez-les avec une case à cocher.

Si vous mettez le signe plus au début de la ligne, il formate différemment:

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

J'utilise des parties de chaîne de largeur fixe (remplies d'espaces) pour éviter que le formateur ne gâche mon indentation de chaîne SQL. Cela vous donne des résultats mitigés et ne fonctionnera pas lorsque les espaces ne sont pas ignorés comme dans SQL, mais peuvent être utiles.

    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                          ";

Terminez chacune des lignes par une double barre oblique "//". Cela empêchera l'éclipse de les déplacer tous sur la même ligne.

Méthode alternative: dans Eclipse 3.6, sous "Line Wrapping" puis "General Settings" il y a une option pour "Ne jamais joindre des lignes déjà wrappées". Cela signifie que le formateur encapsulera de longues lignes mais n'annulera aucun emballage que vous avez déjà.

@xpmatteo a la solution pour désactiver des parties de code, mais en plus de cela, les paramètres d'éclipse par défaut doivent être définis pour ne formater que les lignes de code modifiées au lieu du fichier entier.

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

Cela aurait empêché cela de se produire en premier lieu puisque vos collègues reformatent du code qu'ils n'ont pas réellement changé. Il s'agit d'une bonne pratique pour éviter les incidents qui rendent le diff sur votre contrôle de source inutile (lorsqu'un fichier entier est reformaté en raison de différences de réglage de format mineures).

Cela empêcherait également le reformatage si l'option on / off tags était désactivée.

Les commentaires fantômes, ajoutant //où vous voulez de nouvelles lignes, sont super!

1. @Formatter: off ajoute une référence du code à l'éditeur. Le code ne devrait, à mon avis, jamais avoir de telles références.

2. Les commentaires fantômes (//) fonctionneront quel que soit l'outil de formatage utilisé. Peu importe Eclipse ou InteliJ ou tout éditeur que vous utilisez. Cela fonctionne même avec le très joli format Google Java

3. Les commentaires fantômes (//) fonctionneront partout dans votre application. Si vous avez également Javascript et utilisez peut-être quelque chose comme JSBeautifier . Vous pouvez également avoir un style de code similaire dans Javascript.

4. En fait, vous voulez probablement un formatage correct? Vous souhaitez supprimer les espaces / tabulations mixtes et les espaces de fin. Vous souhaitez mettre en retrait les lignes selon la norme de code. Ce que vous ne voulez pas, c'est une longue file d'attente. Voilà, et seulement cela, ce que le commentaire fantôme vous donne!

Ce hack fonctionne:

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

Je suggère de ne pas utiliser le formateur. Un mauvais code devrait être mauvais et non artificiellement bon. Un bon code prend du temps. Vous ne pouvez pas tricher sur la qualité. Le formatage fait partie de la qualité du code source.