Lets you define the wrapping policy for operators. Line wrapping will often occur with statements that consist of several (possibly long) expressions. Here you specify whether line wrapping should occur before or after the expression operator.

Wrap before operators

When enabled, line breaks will be inserted before operators.

if ((condition1 && condition2)
    || (condition3 && condition4)
    || !(condition5 && condition6)) {
    doSomethingAboutIt();
}

Wrap after operators

When enabled, line breaks will be inserted after operators.

if ((condition1 && condition2) ||
    (condition3 && condition4) ||
    !(condition5 && condition6)) {
    doSomethingAboutIt();
}

Please note that wrapping for the comma and dot operator is currently always performed after the operators! If you happen to use Sun Brace styling, you might want to enable continuation indentation for blocks to let the statement body stand out. See “Block continuation indentation” for more information.

Lets you specify for which code elements line breaks should be kept.

Declaration parameters

When enabled, existing line breaks after the commas of declaration parameters are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.6

void test( String rName,
           boolean rPendandic ) {
    ...
}

After formatting this code could look like this (because everything fits in one line):

void test( String rName, boolean rPendandic ) {
    ...
}

But with the "Keep line breaks" option enabled, it may look like this:

void test( String rName,
           boolean rPendandic ) {
    ...
}

Alternatively, you might want to use the //J:KEEP+ pragma comment to keep line breaks on a case by case basis.

Call arguments

When enabled, existing line breaks after the commas of call arguments are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.6

obj.method1( test,
             test2,
             test3 );

After formatting this code could look like this (because everything fits in one line):

obj.method1( test, test2, test3 );

But with the "Keep line breaks" option enabled, it may look like this:

obj.method1( test,
             test2,
             test3 );

Alternatively, you might want to use the //J:KEEP+ pragma comment to keep line breaks on a case by case basis.

Operators

When enabled, existing line breaks before or after infix operators and the comma operator of method declaration parameters or method call arguments are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.0

if ((condition1 && condition2)
    || (condition3 && condition4)
    || !(condition5 && condition6))
{
    ...
}

After formatting this code could look like this (because not everything fits in one line and not line breaks are forced):

if ((condition1 && condition2) || (condition3 && condition4) ||
    !(condition5 && condition6))
{
    ...
}

But with the "Keep line breaks" option enabled, it may look like this:

if ((condition1 && condition2) ||
    (condition3 && condition4) ||
    !(condition5 && condition6))
{
    ...
}

Please note that it does not matter what wrapping policy for operators you choose. Jalopy will keep line breaks even if the operators move!

String concats

When enabled, existing line breaks before or after the plus operator of concatenated string literals are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.0.1

query = "select a.prop_text, "
        + "       a.contest_title, "
        + "  from contest a "
        + "  where a.language_code = b.language_code "
        + "    and b.bob = c.bob "
        + "    and a.x = ? "
        + "  order by a.bob, "
        + "           c.language";

After formatting this code could look like this:

query = "select a.prop_text, " + "       a.contest_title, " +
    "  from contest a "  + "  where a.language_code = b.language_code " +
    "    and b.bob = c.bob " + "    and a.x = ? " + "  order by a.bob, " +
    "           c.language";

But with the "Keep string concats" option enabled, it may look like this:

query = "select a.prop_text, " +
    "       a.contest_title, " +
    "  from contest a " +
    "  where a.language_code = b.language_code " +
    "    and b.bob = c.bob " +
    "    and a.x = ? " +
    "  order by a.bob, " +
    "           c.language";

Please note that it does not matter what wrapping policy for operators you choose. Jalopy will keep line breaks even if the operators move!

Array elements

When enabled, existing line breaks after the separator comma between individual array elements are kept. Otherwise line wrapping is performed according to the current settings if there can be no pragma comment found that indicates otherwise.

Since 1.5

String[] foo = new String[]
    {
        "foo",
    };

String[] bar = new String[]
    {
        "bar",
        "car",
    };

String[] foo = new String[] { "foo", };

String[] bar = new String[] { "bar", "car", };

String[] foo = new String[]
    {
        "foo",
    };

String[] bar = new String[]
    {
        "bar",
        "car",
    };

String[] foo = new String[] { "foo", };

String[] bar = new String[]
    { //J:KEEP
        "bar",
        "car",
    };

Alternatively, you might want to use the //J:KEEP+ pragma comment to keep line breaks on a case by case basis.

Strictly obey "Keep line breaks"

When using endline indentation, line breaks may not always be kept because doing so would break the endline indent contract and lead to inconsistent indentation behavior. Enabling this option will cause Jalopy to keep existing line breaks even in such cases. Please note that this option is only available when endline indentation is enabled and any of the "Keep line breaks" options selected!

Since 1.8

String firstSymbol = eraseNonBreakingSpaceFromSymbol(
    symbol1, symbol2);

When the option is disabled, Jalopy won’t keep the line break before the first call argument because it goes against the endline indentation rules.

String firstSymbol = eraseNonBreakingSpaceFromSymbol(symbol1,
                                                     symbol2);

But if you really favor keeping the line break, enabling the option would yield:

String firstSymbol = eraseNonBreakingSpaceFromSymbol(
        symbol1, symbol2);

Treat two string literals as string concatenation

This option lets you control what is considered a string concatenation. By default, Jalopy treats the plus (+) operator as a string concatenation when either one of the operands is a string literal. But you might want to narrow this behavior to only treat two string literals as a string concatenation. Please note that this option is only available when any of the "Keep line breaks" options is selected!

Since 1.8

String query = "select a.prop_text, "
               + "       a.contest_title, "
               + "  from contest a "
               + "  where a.language_code = b.language_code ";

String name = "Walther"
              + getNick();

When this option is disabled, all operators in the example above are considered string concatenations and therefore line breaks are kept.

String query = "select a.prop_text, "
               + "       a.contest_title, "
               + "  from contest a "
               + "  where a.language_code = b.language_code ";

String name = "Walther" + getNick();

When enabled, only those plus operators with two string literals on either side would retain any line breaks like in the example above.

Disable wrapping for complex expressions

For complex expressions a common technique to enhance readability is to break the expression into several sub-expressions that can be stored in temporary variables that are placed on different lines.

if (conditionOne &&                                |
    ("foo".equals(aStr) || "bar".equals(aStr))     |
  doSomething();                                   |

boolean conditionTwo = "foo".equals(aStr);         |
boolean conditionThree = "bar".equals(aStr);       |
                                                   |
if (conditionOne &&                                |
    (conditionTwo || conditionThree))              |
  doSomething();                                   |

In order to determine occurrences of complex expressions, enabling this option will cause automatic line wrapping to be disabled when a complex expression gets printed. A warning message will be logged in the Printer category that informs you about the location of the expression.

Since 1.5

                                                   |
if (conditionOne && (conditionTwo || conditionThree))
  doSomething();                                   |

Avoid bare left parenthesis

With Endline indentation and "Wrap on-demand after left parenthesis" or "Keep line break for operators" enabled, line breaks after left parentheses may look ugly. If this option is enabled, such line breaks are avoided. This option was mainly introduced to fix some unwanted behavior of earlier releases without breaking compatibility. It is recommended to have it enabled.

Since 1.4

this.customerNumber = new CustomerNumber(
                                         ServiceManager.createService());

this.customerNumber = new CustomerNumber(ServiceManager.createService());

Prefer within call after assignment

This option lets you define where a line wrap should preferably occur for call statements after assignments that don’t fit into the maximal line length. The option is only meant to let you adjust behavior when “Prefer wrap after assignments” has been enabled. Please see explanation there.

Since 1.7

nuMBeans =
     NuvegaPropertiesHandler.getNNuvegaArrayProperty(
         NuvegaProperties.PROPERTIES_FILE_NUVEGA_BEAN_NAME);

nuMBeans = NuvegaPropertiesHandler.getNNuvegaArrayProperty(
         NuvegaProperties.PROPERTIES_FILE_NUVEGA_BEAN_NAME);

Prefer within call arguments

This option lets you define where a line wrap should preferably occur for call arguments that does not fit into the maximal line length. Normally a line gets wrapped before a call argument that don’t fit into the maximal line length. Enabling this option will cause a line break inserted within the call argument for operator expressions when the operator expression is not immediately preceded with or followed by another operator expression.

Since 1.5

failed(output, "a" + "b", null,                           |
        "Failed to open prefs: " + e.getMessage());       | 
                                                          |

As you can see from the above example a line break is inserted before the third argument as it would exceed the maximal line length when printed in the same line.

failed(output, "a" + "b", null, "Failed to open prefs: "  |
       + e.getMessage());                                 |
                                                          |

When the option is enabled, the line break happens within along the operator of the third argument.

failed(output, "a" + "b",                                 |
       "Failed to open prefs: " + e.getMessage());        |
                                                          |

But if two operator expressions follow immediately, the standard behavior applies in order to enhance readability.