¿Cómo desactivar el formateador de código Eclipse para ciertas secciones del código Java?

Tengo un código Java con sentencias SQL escritas como cadenas Java (por favor, sin llama OR / M, el SQL incorporado es lo que es, no es mi decisión).

He dividido semánticamente las declaraciones SQL en varias cadenas concatenadas en varias líneas de código para facilitar el mantenimiento. Entonces, en lugar de algo como:

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

Tengo algo como:

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

Este estilo hace que el SQL sea mucho más fácil de leer y mantener (en mi humilde opinión), especialmente para consultas más grandes. Por ejemplo, puedo poner mi editor en modo "sobrescribir" y modificar el texto en el lugar con bastante facilidad.

Tenga en cuenta que este problema se generaliza más allá del ejemplo particular de SQL. Cualquier código que esté escrito con cualquier formato vertical, particularmente construcciones tabulares, es susceptible de ser destruido por una bonita impresora.

Ahora, algunos miembros del proyecto usan el editor Eclipse y el formato semántico a menudo se destruye cuando formatean un archivo fuente completo.

¿Hay alguna manera de indicarle a Eclipse que ignore ciertas líneas de origen con respecto al formato?

Estoy buscando algo así como un comentario especial que alterna el formateador Eclipse. Idealmente, dicho comentario podría ser configurable para que sea lo que elijamos, y otros formateadores también podrían programarse para respetarlo:

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

Obviamente, una "solución" es hacer que los miembros de nuestro equipo se estandaricen en algún formateador externo como Jalopy o JIndent , pero de eso no se trata esta pregunta (tampoco de mi decisión sobre este proyecto): específicamente estoy buscando una manera de evite el formateador de Eclipse sobre una base ad-hoc.

Idealmente, una solución me permitirá insertar instrucciones para el formateador de Eclipse sin requerir que los miembros del equipo que utilicen Eclipse realicen ninguna reconfiguración IDE (además de posiblemente elegir un comentario de comando agnóstico del formateador: STOP-ECLIPSE-FORMATTING→ STOP-FORMATTING).

Eclipse 3.6 le permite desactivar el formato colocando un comentario especial, como

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

Las funciones de encendido / apagado tienen que ser en "ON" en las preferencias de Eclipse: Java > Code Style > Formatter. Haga clic en Edit, Off/On Tags, habilite Enable Off/On tags.

También es posible cambiar las cadenas mágicas en las preferencias: consulte los documentos de Eclipse 3.6 aquí .

Más información

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

Esta preferencia le permite definir una etiqueta para deshabilitar y una etiqueta para habilitar el formateador (consulte la pestaña Etiquetas de Apagado / Encendido en su perfil de formateador):

También debe habilitar las banderas de Java Formatting

AFAIK de Eclipse 3.5 M4 en el formateador tiene una opción "Nunca unir líneas" que preserva los saltos de línea del usuario. Tal vez eso hace lo que quieres.

De lo contrario, está este truco feo

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

Ver esta respuesta en SO .

Hay otra solución que puede usar para suprimir el formato de comentarios de bloque específicos. Use /*-(observe el guión) al comienzo del comentario de bloque, y el formato no se verá afectado si formatea el resto del archivo.

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

Fuente: Documentación en Oracle .

En lugar de desactivar el formato, puede configurarlo para que no se una a las líneas ya ajustadas. Similar a la respuesta de Jitter, aquí está para Eclipse STS:

Propiedades → Estilo de código Java → Formateador → Habilitar ajustes específicos del proyecto O Configurar ajustes del espacio de trabajo → Editar → Ajuste de línea (pestaña) → marque "Nunca unir líneas ya ajustadas"

Guardar, aplicar.

Debe activar la capacidad de agregar las etiquetas de formateador. En la barra de menú vaya a:

Windows → Preferences Java → Code Style → Formatter

Presiona el Editbotón. Elige la última pestaña. Observe la casilla de encendido / apagado y actívelos con una casilla de verificación.

Si coloca el signo más al comienzo de la línea, se formatea de manera diferente:

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

Estoy usando partes de cadena de ancho fijo (rellenadas con espacios en blanco) para evitar que el formateador estropee mi sangría de cadena SQL. Esto le brinda resultados mixtos y no funcionará donde no se ignore el espacio en blanco como en SQL, pero puede ser útil.

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

Termine cada una de las líneas con una barra doble "//". Eso evitará que el eclipse los mueva a todos en la misma línea.

Método alternativo: en Eclipse 3.6, en "Ajuste de línea" y luego en "Configuración general" hay una opción para "Nunca unir líneas ya ajustadas". Esto significa que el formateador envolverá líneas largas pero no deshacerá ningún ajuste que ya tenga.

@xpmatteo tiene la respuesta para deshabilitar porciones de código, pero además de esto, la configuración de eclipse predeterminada debe establecerse para formatear solo las líneas de código editadas en lugar de todo el archivo.

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

Esto habría evitado que sucediera en primer lugar ya que sus compañeros de trabajo están formateando el código que en realidad no cambiaron. Esta es una buena práctica para evitar contratiempos que hacen que la diferencia en el control de su fuente sea inútil (cuando se formatea un archivo completo debido a diferencias menores en la configuración del formato).

También evitaría el formateo si la opción de etiquetas de encendido / apagado estaba desactivada.

¡Los comentarios fantasmas, que agregan //donde quieres nuevas líneas, son geniales!

1. @Formatter: off agrega una referencia del código al editor. El código debería, en mi opinión, nunca tener tales referencias.

2. Los comentarios fantasma (//) funcionarán independientemente de la herramienta de formato utilizada. Independientemente de Eclipse o InteliJ o cualquier editor que use. Esto incluso funciona con el muy agradable formato Google Java

3. Los comentarios fantasmas (//) funcionarán en toda su aplicación. Si también tiene Javascript y quizás use algo como JSBeautifier . Puede tener un estilo de código similar también en Javascript.

4. En realidad, probablemente quieras formatear, ¿verdad? Desea eliminar tabuladores / espacios mixtos y espacios finales. Desea sangrar las líneas de acuerdo con el código estándar. Lo que NO quieres es una larga cola. ¡Eso, y solo eso, es lo que te da el comentario fantasma!

Este truco funciona:

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

Sugeriría no utilizar el formateador. El código incorrecto debe verse mal, no artificialmente bueno. El buen código lleva tiempo. No puedes engañar a la calidad. El formateo es parte de la calidad del código fuente.