Jalopy Release History

Release History Versions 1.0 - 1.4

Provides the details about the changes, fixes and enhancements between the releases 1.0 - 1.4.

1.4 (2004-12-20)

New features

The IDE Plug-ins now provide cursor restore at the column level. Formatting an opened editor view retains the cursor position relative to the currently edited code element. Cursor restore now works within comments as well. Suggested by Daryl Robbins
The installer now provides the ability to perform silent installation (a.k.a. unattended setup). Please refer to the Installation section in the manual for more information
You can now control whether and what block bodies should be indented (let's you achieve the Whitesmith brace style). Refer to the Indentation section in the manual for more information. Suggested by Kris Dines and Sam Lalani
Curly braces may now be inserted automatically around the statement lists of labeled statements inside switch blocks. Refer to the Braces section in the manual for more information. Suggested by Harald Lübeck and Brian Brown
Line breaks after left parentheses may now be avoided. Refer to the Wrapping section in the manual for more information. Suggested by John Kercheval
Parameterized types may now be wrapped. Refer to the Wrapping section in the manual for more information. Suggested by Elmar Sonnenschein
Wrapping of import declarations is now possible. Refer to the Wrapping section in the manual for more information. Suggested by Ankit Mathur
New blank lines option to add blank lines after multiple assignment expressions. Refer to the Blank Lines section in the manual for more information. Suggested by John Kercheval
The number of blank lines printed between the different main declaration sections is now configurable. Refer to the Blank Lines section in the manual for more information. Suggested by Bruce Eckel
The number of blank lines before the first class, interface, enum or annotation declaration of a compilation unit is now configurable. Refer to the Blank Lines section in the manual for more information. Suggested by Bruce Eckel
static imports may now be grouped. Refer to the Imports section in the manual for more information. Suggested by Elmar Sonnenschein
The style of separator comments is now configurable. Refer to the Sorting section in the manual for more information. Suggested by Daniel Haas and Jason Us
Continuation indentation may be used for method and constructor parameters upon wrapping. Refer to the Indentation section in the manual for more information. Suggested by Colin Greenlaw
Enum declarations may be printed in a single line when possible. Refer to the Braces section in the manual for more information. Suggested by Elmar Sonnenschein.
A line break may now be forced before the class, interface etc. keyword of class, interface, enum and annotation declarations. Refer to the Wrapping section in the manual for more information. Suggested by Daniel Haas
NetBeans Plug-in: NetBeans 4.0 is now supported as well
In it now possible to format the files/directories selected in jEdit's File System Browser. Refer to the jEdit Plug-in section in the manual for more information

Changes

JBuilder bookmarks restore has been disabled because of problems with the most recent JBuilder 2005 patch. To enable it for prior versions you can set the system property "triemax.jalopy.disable.annotations" to "false". This means may be achieved manually on the command line

%jbuilder -Dtriemax.jalopy.disable.annotations=false

or by adding a vmparam directive to the jdk.config configuration file.

# Use the embedded JDK provided with JBuilder and
# override the default heap growth / shrinkage rates

javapath ../jdk1.4/jre/bin/client/jvm.dll

vmparam -Xminf0.2
vmparam -Xmaxf0.2

# Add the "tools" JAR to the path since the JDK doesn't
# do so automatically
addpath ../jdk1.4/lib/tools.jar


# Force standard VM settings for all applications
vmparam -Xverify:none

# Enable Jalopy bookmark restore
vmparam -Dtriemax.jalopy.disable.annotations=false

...

"Format-on-save" does no longer trigger formatting when the file save was initiated by some SCM action for the Eclipse, JBuilder and JDeveloper Plug-ins. If you want to enforce that files are formatted upon SCM checkin, consider integrating the formatter directly on the server side
The Javadoc parser is now more loose w/r to processing of < (less than) signs
Code like
```
/** That is: "a < b < c < d" is the same as "a < b & b < c & c < d" OR */
```
now formats fine whereas prior versions would yield parsing errors
When wrapping for chained method calls were forced, a line break was always printed before the first chain link. Now a line break before the first chain link gets only printed when an identifier appears before the method or the method contains qualification. The change may affect formatting output!
For comments in front of elements, the comments blank lines options were used, i.e. depending on your blank lines settings additional blank lines could be added. Now, only existing blank lines are kept, but new ones only inserted when dictated by the element after the comment. The change may affect formatting output!
When printing else statement blocks that only consists of a single return, break or continue statement that is not enclosed with curly braces (and no curly braces should be inserted), the "Blank lines before control statements" setting is no longer used. Instead no blank lines are ever added. Please note that existing blank lines are still kept (when the settings indicates so), thus you won't see any diffs with existing code.
```
if (true)
    break;
else
    return;
```
When the "Blank lines before control statements" setting was '1', it was printed
```
if (true)
    break;
else

    return;
```
Now it is printed
```
if (true)
    break;
else
    return;
```
The tab indentation options have been moved to the General indentation page
The array wrapping options have been moved to the General wrapping page
Updated JDOM to 1.0

Bug fixes

Eclipse Plug-in: the Plug-in failed to work under Mac OS X. Much thanks to Adrian Newby from Intelligent Connections, Inc. for his more than generous help and Cyrill Rüttimann for his useful advice
The "Wrap on-demand after left parenthesis" option did not work for method declarations parameter lists when Endline indentation was enabled. Please note that you can enforce the former behavior with the new "Avoid bare left parenthesis". The fix may affect formatting output!
Wrong line break inserted before creator calls depending on the settings. The fix may affect formatting output!
With "Insert expression parentheses" enabled, no parentheses was added for the instanceof operator. The fix may affect formatting output!
When no blank lines could be found between elements and comments, Jalopy always preferred to associate comments with the next element. Reported by John Kercheval. The fix may affect formatting output!
With "Keep line breaks for operators" enabled, line breaks where not always kept. Reported by John Kercheval. The fix may affect formatting output!
With endline indentation enabled, blank lines between elements of multi-array initializers were not correctly printed. The fix may affect formatting output!
Multi-arrays which contained just one element were wrongly printed. Reported by John Kercheval. The fix may affect formatting output!
With endline indentation enabled, closing parentheses were not correctly aligned with the corresponding left parentheses when a line break occurred before the closing parenthesis. The fix may affect formatting output!
With endline indentation enabled, comments after elements could be wrongly aligned. Reported by John Kercheval. The fix may affect formatting output!
With endline indentation enabled, method declarations could become wrongly indented, when an array type assignment expression did not fit into the maximal line length. Reported by John Kercheval and Don Mason. The fix may affect formatting output!
When "Keep blank lines up to" disabled, the blank lines settings for comments were ignored, which could lead to wrongly removed blank lines. Reported by John Kercheval. The fix may affect formatting output!
With either of the comment reflow options enabled, one blank line above the specified blank line amount was printed after comments that got reflowed. Reported by Carsten Langer. The fix may affect formatting output!
With Javadoc formatting enabled, a line break could be printed between the closing brace of an inline tag and a dot right after the brace. Reported by Carsten Langer. The fix may affect formatting output!
Comments after switch statements were not correctly indented when "Indent case from switch" was disabled. The fix may affect formatting output!
Comments after case statements were not correctly indented. The fix may affect formatting output!
Prefix increment or decrement expressions that appeared right after blocks and contained comments before could lead to wrong number of blank lines between block and expression. The fix may affect formatting output!
Comments before right parentheses were wrongly printed. The fix may affect formatting output!
Comments after the rhs of an operator enclosed with parentheses were wrongly printed after the right parenthesis. The fix may affect formatting output!
With "Insert expression parentheses" disabled, expressions could be wrongly wrapped. Reported by Elmar Sonnenschein. The fix may affect formatting output!
Array initializers as part of an array creation expression, could exceed the maximal line length. Reported by Elmar Sonnenschein. The fix may affect formatting output!
With Javadoc formatting enabled, trailing white space after Javadoc inline tags could occur. The fix may affect formatting output!
With "Align method declaration parameters" enabled, the parameters were wrongly aligned when a vararg was part of the list. Reported by Elmar Sonnenschein. The fix may affect formatting output!
With Javadoc formatting enabled, a blank space was inserted after curly braces. Reported by Elmar Sonnenschein
```
/**
 * "{a}+"
 */
```
was wrongly formatted as
```
/**
 * "{ a} +"
 */
```
Now it does
```
/**
 * "{a}+"
 */
```
With Single-line comment formatting enabled, the blank space after the comment delimiter was printed in any case. Now it is only printed if the text does not start with another slash. Reported by Bruce Eckel
```
/// :~
```
was printed as
```
// / :~
```
Now it does
```
/// :~
```
The same held true for the different pragma comments. Reported by Freek-Jan Scherpenzeel

Depending on your blank lines settings, comments that were not lined up with the next element, could lead to unstable formatting because no blank line was printed before the comment after the first run

if (resp != null) { // do processing for two way calls
        // The Interceptor writer should take care
        // of invoking hooks in oneway case

    // consume any others that may be defined
    POAORB myorb = (POAORB) orb;
}

was first printed as

if (resp != null) { // do processing for two way calls
    // The Interceptor writer should take care
    // of invoking hooks in oneway case

    // consume any others that may be defined
    POAORB myorb = (POAORB) orb;
}

and if blank lines should be printed before single-line comments, finally leading to

if (resp != null) { // do processing for two way calls

    // The Interceptor writer should take care
    // of invoking hooks in oneway case

    // consume any others that may be defined
    POAORB myorb = (POAORB) orb;
}

The latter is now already achieved after the first run

"Insert logging conditional" failed for debugging calls inside if statements. Reported by Torben Lorentzen. The fix may affect formatting output!

With "Override headers" enabled, headers were duplicated when no package statement was present and other comments appeared after the header. Reported by John Kercheval

/*
 * This file is a part of the Foo Superior product
 *
 * Copyright (c) 1999-2004 Foo, Inc.
 * 1430 Second Street, Mars, VI 32759, U.S.A.
 * All rights reserved.
 * www.foo.com
 */
//
// Copyright (c) 1999-2004 Foo, Inc.
// 1430 Second Street, Mars, VI 32759, U.S.A.
// All rights reserved.
//
import java.io.*;

was wrongly printed as

/*
 * This file is a part of the Foo Superior product
 *
 * Copyright (c) 1999-2004 Foo, Inc.
 * 1430 Second Street, Mars, VI 32759, U.S.A.
 * All rights reserved.
 * www.foo.com
 */
/*
 * This file is a part of the Foo Superior product
 *
 * Copyright (c) 1999-2004 Foo, Inc.
 * 1430 Second Street, Mars, VI 32759, U.S.A.
 * All rights reserved.
 * www.foo.com
 */
//
// Copyright (c) 1999-2004 Foo, Inc.
// 1430 Second Street, Mars, VI 32759, U.S.A.
// All rights reserved.
//
import java.io.*;

With "Array brackets after identifier" enabled, parameterized types that contained an array type parameter were wrongly printed. Reported by Harald Lübeck
```
XX<Foo, Bar[]> xx;
```
was wrongly printed as
```
XX<Foo, Bar> xx[];
```
Now it does (depending on your settings)
```
XX<Foo, Bar[]> xx;
```
Regression: custom ordering of method declarations did not work. Reported by Jason Winshell
Regression: The two code inspector checks "Never declare Exception" and "Never declare Throwable" were not working. Reported by Ankit Mathur
The Java code inspector check "Return zero-length arrays, not nulls" did not work. Reported by Ajay Goil

With "Keep line breaks for operators" enabled, line breaks before the rhs of an operator where not kept when the rhs was a method call. Reported by Ken Kercheval

if ((ad.getEntityID() == monitorID) &&                                     |
        (ad.getSchType() == schType) &&                                    |
        ad.getStartTime().equals(start) &&                                 |
        ad.getStopTime().equals(stop) &&                                   |
        (ad.getShouldSample() == shouldSample)) {                          |
}                                                                          |

was wrongly printed as

if ((ad.getEntityID() == monitorID) &&                                     |
        (ad.getSchType() == schType) && ad.getStartTime().equals(start) && |
        ad.getStopTime().equals(stop) &&                                   |
        (ad.getShouldSample() == shouldSample)) {                          |
}                                                                          |

Now it yields

if ((ad.getEntityID() == monitorID) &&                                     |
        (ad.getSchType() == schType) &&                                    |
        ad.getStartTime().equals(start) &&                                 |
        ad.getStopTime().equals(stop) &&                                   |
        (ad.getShouldSample() == shouldSample)) {                          |
}                                                                          |

NetBeans guard comments could be modified when "Format single-line comments" and/or "Wrap single-line comments" were enabled. Reported by Chris Lowe and Mark D. Johnston

Constant-specific methods (i.e. methods declared in an enum constant) lead to a NPE. Reported by Daniel Schömer

public enum Operation {
    PLUS { double eval(double x, double y) { return x + y; } },
    MINUS { double eval(double x, double y) { return x - y; } },
    TIMES { double eval(double x, double y) { return x * y; } },

    // Do arithmetic op represented by this constant
    abstract double eval(double x, double y);
}

Nested normal annotations lead to NPE. Reported by Bruce Eckel

@SQLString(value=30, constraints=@Constraints(primaryKey=true))
String handle;

NetBeans Plug-in: After having formatted a file with guarded sections that did not already contain an event handler section, adding a new event handler was not possible without closing the file and re-open it. Reported by Mark D. Johnston
Fixed NPE when Endline indentation was enabled and multi-variables appeared in for statements. Reported by Ruedi Keller

1.3 (2004-08-31)

New features

Javadoc comment generation may now be disabled for Getters and Setters. Refer to the Javadoc section in the manual for details. Suggested by Andreas Brenk
Separator comments may now be inserted between methods. Refer to the Sorting section in the manual for details. Suggested by Roger Alexander
Trailing comments identifying the end of brace blocks may be inserted where desired. Refer to the Comments section in the manual for more information. Suggested by Roger Alexander
Added option to determine chunks by line wrapping. Refer to the Indentation section in the manual for more information. Suggested by Bill O'Rourke
Javadoc comments for methods may now be printed in just one line. Refer to the Javadoc section in the manual for more information. Suggested by Carsten Langer
You can now control the behavior during interpolation of the "property.name" local environment variable. Refer to the Javadoc section in the manual for more information. Suggested by Harald Lübeck
Wrapping may be forced after the class and throws keywords. Refer to the Wrapping section for more information. Suggested by Jesper Thaning
The auto-correction of misspelled Javadoc tag names is now configurable. Refer to the Wrapping section section in the manual for more information. Suggested by Jose Luiz Junior
New option to control whether wrapping should occur before method names when necessary. Refer to the Wrapping section section in the manual for more information
Wrapping may now be forced before ternary colons when a line break happened before the ternary question. Refer to the Wrapping section section in the manual for more information
The "Blank Lines for control statements" option may now be ignored for break statements inside of switch blocks. Refer to the Blank Lines section in the manual for more information. Suggested by Elmar Sonnenschein and Bill O'Rourke
The "Blank Lines for blocks" option may now be ignored for block inside of switch blocks. Refer to the Blank Lines section in the manual for more information. Suggested by Bill O'Rourke

Changes

With Javadoc formatting enabled, templates are now formatted during Javadoc generation. The former behavior was to always insert templates as-is which could lead to unstable formatting between 1st and 2nd run when the template style was not matching the style expressed by the formatting options
When printing statement blocks that only consists of a single return, break or continue statement that is not enclosed with curly braces (and no curly braces should be inserted), the "Blank lines before control statements" setting is no longer used. Instead no blank lines are ever added. Please note that existing blank lines are still kept (when the settings indicates so), thus you won't see any diffs with existing code.
```
if (true)
  return;
```
When the "Blank lines before control statements" setting was '1', it was printed
```
if (true)

  return;
```
Now it is printed
```
if (true)
  return;
```
The "class.name" variable can now be used in all Javadoc templates (not only for Method/Interface/Ctor as before)
The options on the General tab on the Javadoc settings page has been split into two separate tabs: Generation and Correction
The code inspector naming settings page now appears as a separate tab on the Code Inspector settings page

Bug fixes

Comments before typed methods were removed when the method contained no modifier
```
/* Comment */
<T> void doIt(T t) {
 ...
}
```
was wrongly formatted as
```
<T> void doIt(T t) {
 ...
}
```
Now it does
```
/* Comment */
<T> void doIt(T t) {
 ...
}
```
Reported by Carsten Langer
Static import declarations were transformed to their standard counterparts.
```
import static TrafficLight.*;
```
was wrongly printed as
```
import TrafficLight.*;
```
Now it does
```
import static TrafficLight.*;
```
Reported by Dennis Haupt

With "Reflow comments" enabled, blank lines were not kept when reflowing multi-line comments with leading asterixes

/*                                                                     |
 * A multiline comment with an empty line so not to reflow the second part
 * after the first part.                                               |
 *                                                                     |
 * This is expected to stay separated, as described in the jalopy      |
 * preferences page.                                                   |
 */                                                                    |

was wrongly formatted as

/*                                                                     |
 * A multiline comment with an empty line so not to reflow the second  |
 * part after the first part. This is expected to stay separated, as   |
 * described in the jalopy preferences page.                           |
 */                                                                    |

Now it does

/*                                                                     |
 * A multiline comment with an empty line so not to reflow the second  |
 * part after the first part.                                          |
 *                                                                     |
 * This is expected to stay separated, as described in the jalopy      |
 * preferences page.                                                   |
 */                                                                    |

Reported by Carsten Langer

Return expressions involving anonymous inner classes were wrongly indented with Endline indentation enabled. Reported by Carsten Langer. The fix may affect formatting output!

With both "Wrap multi-line comments" and and "Reflow multi-line comments" enabled, a spurious blank line could be inserted before the last line in a multi-line comment when this line started with a * and was terminated by */.

/* Append third entry to timeline. Third start is 2 ms later than second|
 * start. */                                                            |

was printed as

/* Append third entry to timeline. Third start is 2 ms later than second|
                                                                        |
 * start. */                                                            |

Now it does

/* Append third entry to timeline. Third start is 2 ms later than second|
 * start. */                                                            |

Reported by Carsten Langer

With endline indentation enabled, the bodies of inner class declarations were wrongly indented when the inner class was the rhs expression of an assignment. Reported by Arthur Pope. The fix may affect formatting output!
With Javadoc formatting enabled, XDoclet tags with multiple attributes on one line, that attributes were not split but still printed on one line. Reported by Jose Luiz Junior The fix may affect formatting output!
Some XDoclet tags were not recognized and therefore the descriptions wrongly formatted when Javadoc formatting was enabled: @doc.param, @doc.tag, @jsp.attribute, @jsp.tag, @jsp.validator-init-param, @jsp.variable, @msg.bundle, @soap.method, @soap.service, @struts.action, @struts.action-exception, @struts.action-forward, @struts.form, @struts.form-field, @struts.validator, @struts.validator-args, @struts.validator-var. Reported by Yanik Crépeau
Both new Javadoc inline tags (@code and @literal) were not supported out-of-the-box leading to trashed tags (the work around was to add them manually). Reported by Carsten Langer
When the "Align Method declaration params" option was enabled, parameters were not always aligned even when they should. Reported by Elmar Sonnenschein. The fix may affect formatting output!

With "Reflow single-line comments" enabled, but "Wrap single-line comments" disabled, single-line comments were still wrapped and reflowed!

                            |
// A single-line comment that spans multiple lines and
// exceeds the max. line length
                            |

was wrongly printed as

// A multi-line comment that|
// spans multiple lines but |
// exceeds the max. line    |
// length                   |

Now it does

                            |
// A single-line comment that spans multiple lines and
// exceeds the max. line length
                            |

Reported by Elmar Sonnenschein

With "Align variable assignments" enabled, mixed variable declarations and assignment expressions lead to wrong alignment of the variable expressions. The fix may affect formatting output!
Assignments containing an array access expression could lead to a crossing of the maximal line length. The fix may affect formatting output!
extends and implements clauses could lead to a crossing of the maximal line length when a fully qualified type was used. The fix may affect formatting output!
Fixed a wrapping boundary case for array initializers. The fix may affect formatting output!
Fixed a wrapping boundary case for infix operators enclosed with parenthesis. The fix may affect formatting output!
Fixed a wrapping problem for nested expressions. The fix may affect formatting output!
With "Endline indent" enabled, the left curly brace of array initializers was wrongly indented after assignments when blank lines were present between the assignment and left curly brace. The fix may affect formatting output!
With Javadoc formatting enabled, Jalopy always inserted a blank space after inline tags. Now it preserves the characters(s) immediately following the tag.
```
/** Holds some {@link Foo}s. */
```
was printed as
```
/** Holds some {@link Foo} s. */
```
Now it does
```
/** Holds some {@link Foo}s. */
```
Reported by Carsten Langer

With the "Add @throws tags" option enabled, when adding @throws clauses for exceptions thrown within a method or constructor body, qualified exception names were wrongly printed.

/**
 * Returns the next element.
 *
 * @return  the next element.
 */
public final Object next() {
    if (!hasNext()) {
        throw new java.util.NoSuchElementException("missing next element.");
    }

    return new Double(0.0);
}

Was wrongly formatted as

/**
 * Returns the next element.
 *
 * @return  the next element.
 *
 * @throws  .  DOCUMENT ME!
 */
public final Object next() {
    if (!hasNext()) {
        throw new java.util.NoSuchElementException("missing next element.");
    }

    return new Double(0.0);
}

Now it does (depending on your settings)

/**
 * Returns the next element.
 *
 * @return  the next element.
 *
 * @throws  java.util.NoSuchElementException  DOCUMENT ME!
 */
public final Object next() {
    if (!hasNext()) {
        throw new java.util.NoSuchElementException("missing next element.");
    }

    return new Double(0.0);
}

Reported by Harald Lübeck

With "Align variable identifiers" and "Determine chunks by blank lines" enabled, but "Determine chunks by comments" disabled, variable identifiers were wrongly aligned when originally no blank lines appeared between successive declarations, but blank lines were only inserted because of comments between the declarations. The fix may affect formatting output!
Regression: Generating serial version UID failed when Javadoc formatting was enabled. Reported by Byron K. Appelt
When the description section started with a token that did not fit into the line, a spurious line break was printed after standalone tags. Reported by Elmar Sonnenschein. The fix may affect formatting output!
With the "Use tabs in comments" option enabled, hard tabs could be wrongly inserted for blank spaces. Reported by Elmar Sonnenschein. The fix may affect formatting output!

With the "Add @throws tags" option enabled, throws clauses for exceptions thrown within a method or constructor body were not added when generating Javadoc comments.

public final Object next() {
    if (!hasNext()) {
        throw new java.util.NoSuchElementException("missing next element.");
    }

    return new Double(0.0);
}

Was wrongly formatted as

/**
 * DOCME!
 *
 * @return  DOCME!
 */
public final Object next() {
    if (!hasNext()) {
        throw new java.util.NoSuchElementException("missing next element.");
    }

    return new Double(0.0);
}

Now it does (depending on your settings)

/**
 * DOCME!
 *
 * @return  DOCME!
 *
 * @throws  java.util.NoSuchElementException  DOCME!
 */
public final Object next() {
    if (!hasNext()) {
        throw new java.util.NoSuchElementException("missing next element.");
    }

    return new Double(0.0);
}

When Align Variable assignments was enabled, array type variable declarations were wrongly aligned when the array brackets were specified after the identifier. Reported by Gregory Gerard. The fix may affect formatting output!
The Header blank lines setting did not take correctly precedence over other blank lines settings. Reported by Gregory Gerard. The fix may affect formatting output!
No blank lines were ever printed around headers, when the Override Header settings was disabled. The fix may affect formatting output!
Fields in interfaces were not treated as implicitly public static final and thus the Code Inspector used the wrong regular expression for the naming check. Reported by Carsten Langer
JBuilder Plug-in: Bookmarks were not correctly restored after formatting. Reported by Daryl Robbins and Freek-Jan Scherpenzeel
Ant Plug-in: Regression: Setting custom environment variables via nested "Variable" elements did not work. Reported by Bob McCune
Code like
```
do {
} while (true) // this is a comment
;
```
could not be formatted (threw java.lang.IllegalArgumentException). Reported by Philippe Gaudin
The Collection comments check was missing from the GUI. Reported by Carsten Langer
The Swing configuration dialog did not work with the Liquid Look&Feel. Reported by Elmar Sonnenschein

1.2.1 (2004-07-05)

The indentation of wrapped right parentheses is now configurable (when using standard indentation). You can choose whether you want parentheses to be aligned with the declaration/call or indented according to the current indentation level. See the Indentation section for details. Suggested by Dmitry Gundorov
Hard tabs can now be used for the indentation within comments (former behavior was to never use hard tabs within comments). Refer to the Indentation section in the manual for more information
NetBeans Plug-in: It is now possible to format opened source files with guarded sections. Please note that the editor's undo function does not work when formatting such files!
Javadoc auto-correction has been made more flexible. The behavior can now be configured independently for the description and tag sections, and new options have been added to be able to limit the correction to certain cases when desired. Refer to the Javadoc section in the manual for more information. Suggested by Jason Winshell
New option to enable/disable Javadoc comment generation as a whole. Refer to the Javadoc section in the manual for more information. Suggested by Richard Polish
You can now define the line separator to use in your code convention. Refer to the Global section in the manual. Suggested by Elmar Sonnenschein
The line length for separator comments can now be controlled independently from the general line length setting. Refer to the Comment section in the manual. Suggested by Elmar Sonnenschein
JDeveloper Plug-in: Breakpoints and bookmarks are now restored after formatting an opened document
You can now control whether you prefer a line break after the "return" keyword when the return expression exceeds the maximal line length. Refer to the Wrapping section in the manual

Changes

The Jalopy settings dialog has undergone some restructuring: The "Projects" section has been renamed to "Profiles" to better match user expectation. The "General" section has been renamed to "Global"; the settings Import/Export buttons have been moved from the former "General" page to the "Profiles" page. The misc settings of the former "General->Misc" page can now be found on the "Global->General" settings page (under "Options")
The regex for the boolean getter detection has been changed to "^(is)[A-Z]\w+" (the prefix must now be enclosed with grouping parentheses). If you've applied changes to the regex, you have to update it manually after installation
JDeveloper Plug-in: the Plug-in always used the platform default line separator when writing files. It now obeys the line terminator setting as defined in JDeveloper
jEdit Plug-in: the Plug-in no longer depends on the MessageView Plug-in, therefore the installer removes "messageview-0.1.0.jar" from the jEdit "/jars" directory
JBuilder Plug-in: The format menu item has been moved from the Build menu into the Edit menu
NetBeans Plug-in: The Plug-in no longer displays messages in the NetBeans output window, but instead uses a custom message window that displays messages in a hierarchical tree

Bug fixes

With Javadoc formatting enabled, upon wrapping two lines the first word of a following line could be erased when it would fit into the remaining space of the previous line

/**                                                                        |
 * An <code>ErrorHandler</code> sends {@link Throwable} errors to an       |
 * e-mail address.                                                         |
 */                                                                        |

was wrongly formatted as

/**                                                                        |
 * An <code>ErrorHandler</code> sends {@link Throwable} errors to an       |
 * address.                                                                |
 */                                                                        |

Now it does

/**                                                                        |
 * An <code>ErrorHandler</code> sends {@link Throwable} errors to an e-mail|
 * address.                                                                |
 */                                                                        |

Reported by Michael Allmann

With Javadoc formatting enabled, wrapping could wrongly occur before reaching the maximal line length which could lead to unstable formatting in certain cases. The fix may have a big impact on formatting output!
The handling of hard tabs was seriously flawed: all hard tabs in source files were always replaced by a fixed number of blank spaces during parsing, which could easily lead to wrongly indented comments. Now tabs are replaced in a way that keeps the original indentation. Additionally, Jalopy never used hard tabs within comments. This is now configurable.
A first column comment with hard tabs and a general indentation size of '4'
```
//» »   System.out.println» ("DEBUG: line=" + _line);
```
was wrongly printed as
```
//········System.out.println····("DEBUG: line=" + _line);
```
When using spaces to indent, it now does
```
//······System.out.println··("DEBUG: line=" + _line);
```
Otherwise when using tabs to indent comments, it does
```
//» »   System.out.println» ("DEBUG: line=" + _line);
```
Reported by Elmar Sonnenschein
When the endline indentation policy was enabled, parenthesized expressions were wrongly indented when wrapping occurred. The fix may affect formatting output!
When the standard indentation policy was enabled, no line wrapping happened after the left parenthesis of if, while or do-while statements when the first expression exceeded the maximal line length. The fix may affect formatting output!
With Javadoc checking and/or formatting enabled, separator comments like
```
/*********************************************/
```
lead to parse errors

Upon adding Javadoc comments, blank lines after already present comments were lost

//////////////////////////////////////////////////////////
// Methods
//////////////////////////////////////////////////////////

public String getName() {
    ...
}

was wrongly printed (depending on the settings) as

//////////////////////////////////////////////////////////
// Methods
//////////////////////////////////////////////////////////
/**
 * Returns the value of the Name property.
 *
 * @return  the Name property.
 */
public String getName() {
    ...
}

Now it does

//////////////////////////////////////////////////////////
// Methods
//////////////////////////////////////////////////////////

/**
 * Returns the value of the Name property.
 *
 * @return  the Name property.
 */
public String getName() {
    ...
}

When inserting missing Javadoc comment descriptions, variable expressions were not interpolated.

Depending on the constructor template, code like

/**
 *
 */
public JalopyFehler() {
    ...
}

was formatted as

/**
 * Creates a new $class.name$ object.
 */
public JalopyFehler() {
    ...
}

Now it does

/**
 * Creates a new JalopyFehler object.
 */
public JalopyFehler() {
    ...
}

Reported by Matthias Beil

1.2 (2004-06-03)

IDE projects may now be mapped to Jalopy profiles by defining aliases. Refer to the Profiles section in the manual for more information. Suggested by Jae Gangemi
Method and if-else blocks may now be printed in compact style (just one line). Refer to the Braces section in the manual for more information. Suggested by Andrew Ferguson
if-else statements may now be printed on just one line. Refer to the Misc section in the manual for more information. Suggested by Jae Gangemi
Two new "Wrap always when exceed" options to control behavior for method/ctor declarations and method calls: "Method declaration params" and "Method call args". Suggested by William Hackmann and Elmar Sonnenschein
New wrapping option to force a line break before field names. Refer to the Wrapping section in the manual for more information. Suggested by Jason Winshell
The patterns for the $date$ and $time$ local environment variables are now configurable. Refer to the Environment section in the manual for more information. Suggested by Elmar Sonnenschein
White space before the enum constants arguments list now configurable. Refer to the White space section in the manual for more information
White space before the varargs ellipsis now configurable. Refer to the White space section in the manual for more information
Blank lines around method prototypes in interfaces and abstract classes can now be removed. Refer to the Blank Lines section in the manual for more information. Suggested by Andrew Ferguson
Jalopy 1.1 always printed a line break after enum constants. You can now configure whether you want to force line breaks. The default behavior has been changed to wrap only when necessary (i.e. when the maximal line length would be exceeded). Refer to the Wrapping section in the manual for more information
Separator comments may now be printed without any fill characters. Suggested by Jae Gangemi
Eclipse 3.0 M9 or later now supported out-of-the-box

Bug fixes

The "Wrap multi-line comments" option could expose destructive behavior for certain comments: When the closing comment delimiter did not appear on its own line and the line did not start with a leading *, the comment text of the last line was removed!
```
/* first
 last */
```
was wrongly formatted as
```
/* first
 */
```
Reported by Daryl Robbins

Enabling "Reflow Single-line comments" could lead to uncompilable code when endline comments appeared before an operator and the "Wrap after operators" policy was activated

Code like

if (getProduct().equals(this.getProduct()) // only update the NoBaseService for
                                           // the right Product
         && aTempNoService.getEnd() == null) {
}

was wrongly reformatted to

if (getProduct().equals(this.getProduct()) // only update the
                                           // NoBaseService for
                                           // the right Product &&
        aTempNoService.getEnd() == null) {
}

Reported by Elmar Sonnenschein

The less than (<) sign as part of EJB finder methods and such could easily lead to Javadoc parsing errors

/**
 * @jboss.query
 *   signature = "Long ejbSelectCountBefore(PostEJBLocal post)"
 *   query     = "SELECT COUNT(p2.id) FROM post WHERE p1=?1 AND p2.id<p"
 */

Reported by Jae Gangemi

White space around the less than (<) sign was removed during formatting

/**
 * @jboss.query
 *   signature = "Long ejbSelectCountBefore(PostEJBLocal post)"
 *   query     = "SELECT COUNT(p2.id) FROM post WHERE p1=?1 AND p2.id < p"
 */                                                                  ^^^

was wrongly formatted as

/**
 * @jboss.query
 *   signature = "Long ejbSelectCountBefore(PostEJBLocal post)"
 *   query     = "SELECT COUNT(p2.id) FROM post WHERE p1=?1 AND p2.id<p"
 */                                                                  ^

Reported by Jae Gangemi

Regression: When the "Keep RCS tags" option was enabled, Jalopy wrongly printed existing tags when the tag wasn't specified in expanded tag style in the header template

/*
 * $Header: //depot/jalopy_main/jalopy-doc/src/xdocs/site/history_1_0.xml#4 $
 */

was wrongly printed as

/*
 * : /RVPF/net/sf/rvpf/Version.java,v 1.7 2004/01/10 20:51:36 sfb Exp $
 */

when the header template looked like

/*
 * $Header: //depot/jalopy_main/jalopy-doc/src/xdocs/site/history_1_0.xml#4 $
 */

Using an expanded tag style worked fine

/*
 * $Header: //depot/jalopy_main/jalopy-doc/src/xdocs/site/history_1_0.xml#4 $
 */

Reported by Serge Brisson

When the "Check HTML tags" option was enabled, Jalopy replaced with tags after paragraphs without the optional

/**
 * <p>Instances of two subclasses, {@link java.lang.Error} and
 * {@link java.lang.Exception}, are conventionally used to indicate...
 *
 * <p>A throwable contains a snapshot of the execution stack of its
 * thread at the time it was created. It can also contain a message string...
 */

was wrongly formatted as

/**
 * <p>Instances of two subclasses, {@link java.lang.Error} and {@link
 * java.lang.Exception}, are conventionally used to indicate...<br>
 * A throwable contains a snapshot of the execution stack of its thread at the
 * time it was created. It can also contain a message string...
 */

Now it will be printed

/**
 * <p>Instances of two subclasses, {@link java.lang.Error} and {@link
 * java.lang.Exception}, are conventionally used to indicate...</p>
 *
 * <p>A throwable contains a snapshot of the execution stack of its thread at
 * the time it was created. It can also contain a message string...</p>
 */

Reported by Jason Winshell

Regression: Adding missing @throws tags failed when the "Keep @throws tags" option was enabled and no existing standalone tags present. Reported by Daryl Robbins and Richard Armitage

Inserting missing parentheses around the first operand of the ternary operator could lead to unstable formatting

this(rStart.getTime(), rEnd != null ? rEnd.getTime() : Long.MAX_VALUE); |

was printed to (depending on your settings)

this(rStart.getTime(), (rEnd != null) ? rEnd.getTime()                  |
                                      : Long.MAX_VALUE);                |

and only after the second run became

this(rStart.getTime(),                                                  |
    (rEnd != null) ? rEnd.getTime(): Long.MAX_VALUE);                   |

Reported by Elmar Sonnenschein

The second operand of the Java ternary operator ? : could exceed the line length when enclosed with parentheses. The fix may affect formatting output!
Wrapping for operands of the Java ternary operator ? : that were enclosed with parentheses preferably occurred within the parentheses. Now, wrapping occurs around the operators first. The fix may affect formatting output!
Qualified method calls that appeared after a type cast could exceed the maximal line length. Reported by Daniel Haas. The fix may affect formatting output!
If an assignment expression started with a logical not operator and did not fit into the line, wrapping always happened after the assignment (not only when the "Always wrap after assignment when exceed" option was enabled). The fix may affect formatting output!
The dot character was incorrectly rejected as part of an environment variable key. Reported by Elmar Sonnenschein
No validation happened when changing an existing environment variable. Reported by Elmar Sonnenschein
Arrays were always wrapped according to the Array wrapping options, even when line wrapping was disabled. The fix may affect formatting output!
The Windows startup script did not work with 4NT. Reported by Gregory Gerard

Changes

The local environment variable $project$ was always interpolated to the active Jalopy project, now when using one of the IDE Plug-ins the variable is interpolated to the current IDE project instead
The build-in XDoclet tags has been updated to those of the 1.2.1 release of XDoclet. See the Appendix for the complete list

1.1 (2004-05-06)

J2SE 5.0 language support: generic types, enums, enhanced for loops, static imports, varargs (JSR-201) and metadata facility (JSR-175). Added options: "Space around enhanced for", "Wrap after marker annotations", "Blank lines before enums", "Blank lines before annotations"
The "Format on save" option has been implemented for the Eclipse, IDEA 4.0, JBuilder and JDeveloper Plug-ins
Comment removal is now configurable. Refer to the Comment section in the manual for more information. Suggested by Daryl Robbins and Michael Spoonauer
Sorting of method declarations is now fully configurable using special Javadoc tags. Refer to the Sorting section in the manual for insight. Suggested by Jason Winshell
New Javadoc templates for Javadoc getters/setters. See the Javadoc section in the manual for more information. Added local environment variable $property.name$ that can be used in the getter/setter templates. Suggested by Daryl Robbins and Byron K. Appelt
New code inspector naming convention checks for local final variables and inner classes. Suggested by Marc Lennox
JBuilder Plug-in: added global properties to switch to a specific project, import a code convention and override the "Synchronize settings" option during program startup. Suggested by Marc Lennox
New option to control whether a blank space should be printed before the parenthesis after creator calls. Refer to the White Space section in the manual for an example. Suggested by Jason Winshell
Ant Plug-in: New attribute "project" to temporarily activate a specific project during a formatting run. Suggested by Elmar Sonnenschein
JDeveloper Plug-in: updated to support JDeveloper 10g (support for 9i is still available on request)

Bug fixes

With the "Sorting imports" option enabled, removing duplicate imports removed needed imports, too. Reported by Elmar Sonnenschein and Richard Schulte
The "Format on save" option caused an IllegalStateException when the "Save All" action was triggered in jEdit. Reported by Aslam Karachiwala
Expressions enclosed with parentheses lead to wrong wrapping in some cases. The fix may affect formatting output!
When the "Check HTML tags" option was enabled, XHTML tags like   were printed as  . Reported by Jae Gangemi
When the "Check HTML tags" option was enabled, non-ascii characters were thrashed. Reported by Søren Pedersen
When the "Check HTML tags" option was enabled, Javadoc comments that appeared at invalid positions (not before package, class, interface, constructor, method and field declarations) were wrongly altered. Reported by Cedric Munger. The fix may affect formatting output!
Enabling "Keep @throws tags" had the unwanted side-effect that missing exceptions were no longer automatically added. Reported by Søren Pedersen
Expressions after the return statement could exceed the maximal line length. The fix may affect formatting output!
Assignment alignment did not work correctly when assignment expressions span several lines. Reported by Andre Fleischer. The fix may affect formatting output!
Javadoc tag auto-correction did not work for custom Javadoc tags (NPE during printing). Reported by Jae Gangemi and Richard Schulte
Javadoc comments that only contained a single @todo standalone tag were wrongly printed in some cases. The fix may affect formatting output!
Spaces within wrongly printed for constructor calls when the "Spaces within method calls" option was enabled. The fix may affect formatting output!
The contents of opened editors were wiped out in an IDE when the "Test formatting" option was enabled. Reported by Steven Bromley
Comments before right curly braces lead to wrong indentation in some cases. Reported by Art Rijos. The fix may affect formatting output!
Comments that appeared below multi-variables were wrongly indented when using endline indentation. Reported by Art Rijos The fix may affect formatting output!
Method calls used as last expression in if, while, switch and synchronized statements could lead to a crossing of the maximal line length. The fix may affect formatting output!
Method calls used as last expression in if, while, switch and synchronized statements could lead to a crossing of the maximal line length. The fix may affect formatting output!
Chained method calls where not wrapped at a lower level. The fix may affect formatting output!
HTML tags in Javadoc inline tags lead to insertion of blank spaces. The fix may affect formatting output!
Missing line break before <th> tags. The fix may affect formatting output!
It was not possible to change the grouping depth for undefined packages on the imports settings page
For compilation units denoting a top level interface that did contain any import declarations, the blank lines settings for lines after the package statement was ignored and always one blank line printed. Reported by Jae Gangemi. The fix may affect formatting output!
Regression: Header detection failed when no package declaration was present in the source file, leading to header duplication. Reported by Jason Winshell
JBuilder Plug-in: Triggering a format of selected nodes in the project pane via the popup menu did not work for projects that were part of a project group. Reported by Marc Lennox

Changes

The "Original Tab indent" combo box has been moved to the top of the different sizing options to emphasize the importance of this option. See the related FAQ entry
When installing the Eclipse Plug-in into a link folder, a subdirectory named "Eclipse "was created under the specified folder. This subdirectory won't be created anymore

1.0.4 (2004-03-26)

Bug fixes

With line wrapping disabled, shorthand assignments were transformed to assignments!!! Reported by Brett Keet
With endline indentation policy, auto-split of multi-variables and keep line breaks for operators enabled, formatting of certain multi-variables lead to an NPE. Reported by Anders Wallgren

1.0.3 (2004-03-12)

Array braces may now be aligned with the declaration for array initializers when using standard indentation. Refer to the Indentation section for more information. Suggested by Jason Winshell
White space around can now be controlled separately for the string concat operator. See the White Space section in the manual. Suggested by Vince Broz
Formatting of single-line comments. See the Comment section in the manual for more information. Suggested by Bruce Eckel
Wrapping of single-line and multi-line comments. See the Comment section in the manual for more information. Suggested by Bruce Eckel and Scott Alexander
RCS-style tags in headers and footers can now be kept when existing headers/footers are replaced during formatting. Refer to Header section in the manual. Suggested by Gary Meyer. He also kindly donated the initial code upon which the feature was crafted. Thank you!
The directory where the history file is stored, is now user configurable. See the Global section in the manual. Suggested by Alec Hothan
Force line break between modifiers/return type and name of method/ctor declarations. Refer to the Wrapping section in the manual. Suggested by Jason Winshell
The initialization of the type repository is now more user configurable to allow proper loading even when some dependent libraries could not be found. See the Repository section in the user manual. Suggested by Marc Lennox
Auto-format when opened file is saved. Currently only implemented for the jEdit Plug-in. Refer to the general Global section in the manual. Suggested by Aslam Karachiwala
IDEA 4.0 Plug-in

Bug fixes

Jalopy sometimes printed a trailing blank space after Javadoc parameter descriptions
The history was not flushed before a project switch
Tab characters were not replaced for single-line comments
Method declaration parameters and method call arguments were not correctly lined up with the white space within parentheses options enabled and endline indentation. Reported by Bill Hackmann
Leading indentation wrongly printed (increased indent level) after assignments when using endline indentation. Reported by Vince Broz
Leading indentation wrongly printed after comments when using endline indentation. Reported by Vince Broz
Leading indentation wrongly printed (standard indentation was used) after endline comments in array initializers when using endline indentation. Reported by Vince Broz
The "history" attribute was wrongly documented and missing from the Ant Task. It has been added and the documentation updated. "historymethod" is now just an alias (and may be removed in a future release). Reported by Jason Winshell
The value of array parameter types was wrongly interpolated. Reported by Karsten Silz
On the environment, header/footer and custom tags settings pages it was not possible to change existing values in the list boxes. Reported by Jason Winshell
The import settings page did not allow adding package paths with numbers
Regression: when no Eclipse editor view was opened, formatting of packages failed. Reported by Karsten Silz
For files that only consisted of comments and/or blank lines, the comments and/or blank lines were lost upon formatting when the header feature was disabled
Regression: Jalopy had problems with certain shorthand operators. Reported by Steve Poole and Serge Brisson
Expressions after the assert statement were not correctly indented (not indented at all) with either indentation policy when wrapping occurred. Now the indentation level is correctly increased in such cases. Reported by Elmar Sonnenschein
With HTML checking enabled, the last line of Javadoc comments was removed when it ended with the closing delimiter (*/). Reported by Elmar Sonnenschein
Sometimes the leading column of comments was not correctly indented. Only happened with endline indentation. Reported by Elmar Sonnenschein
Custom XDoclet tags were always reported as misused when tag checking was enabled. When the "Remove misused tags" feature was enabled, they were removed! Reported by Clark Wright
Javadoc closing delimiter wrongly calculated when the template text ended with $. Reported by Thomas Wilcox
Javadoc delimiters wrongly calculated for fields when the template did not contain any literal content. Reported by Alec Hothan
The Global->Misc page was not updated after importing a code convention
The --log option/attribute was not documented for the Console and Ant Plug-ins. Writing the log file was only working from the Console Plug-in. Reported by Clark Wright

Changes

Output style of array initializers changed for Sun brace style: the left curly brace is now printed right after the assignment instead of at a new line.

private static String[] sFields = {
        "LOCATION.ID", "TRACKING_EVENT.CREATE_TIME",
        "TRACKING_EVENT.EVENT_TIME",
    };

Former behavior was

private static String[] sFields =
    {
        "LOCATION.ID", "TRACKING_EVENT.CREATE_TIME",
        "TRACKING_EVENT.EVENT_TIME",
    };

The JBuilder Plug-in now uses the build-in import optimization
Options on the Indentation->Misc settings page have been rearranged
Updated JDOM to 1.0b10

1.0.2 (2004-02-05)

Settings may now be automatically switched between formatting runs. See the Profile section in the manual for more information

Bug fixes

The key binding did not work in Eclipse
When formatting an open editor view, the cursor position was not correctly restored when the caret was in a comment line. Reported by Daryl Robbins
Fixed several cases where Jalopy did not correctly wrap after assignment operators
With certain Look&Feels, the active project entry did not differ from the inactive entries (due to the used font) on the project settings page. Icons have been added to highlight the project state. Reported by Elmar Sonnenschein
Multi-variables were wrongly split in for statements initializers leading to compile time errors!
The console Plug-in did not recognize "=" as the value separator, i.e. specifying an option as --loglevel=DEBUG did not work. Reported by André Fleischer
The sorting settings for element order were not restored upon program startup and thus were effectively not customizable
Sorting of declaration elements was performed using case considerations yielding unsatisfactory ordering
For anonymous inner class declarations that contained another anonymous inner class, missing Javadoc comments before method/ctor declarations were inserted for all contained inner classes
Switching profiles did not work correctly from within Eclipse (required restart). Reported by Elmar Sonnenschein and Jae Gangemi
Detection of file line endings did not work correctly. Reported by John David Beutel
Inserting a serial version UID only worked when the class declared an unqualified interface or super class. Reported by John David Beutel
The insertion of a serial version UID did not work in Eclipse when a project was not part of the workspace. Reported by Byron K. Appelt
Arrays that were printed on a new line were always indented according to the current indentation level. Now indentation happens only when using GNU brace style. Reported by Elmar Sonnenschein

Changes

The class repository has been completely rewritten. The import optimization feature has been reworked and the insertion of a serial version UID and checking for runtime exceptions and errors to omit the insertion of Javadoc standalone tags have been reimplemented to make use of it. Automatic repository support is still only available from within the Ant and JBuilder Plug-ins. Other IDE's will be added soon, but users that currently need these features, please contact support before upgrading
It is no longer necessary to include the Jalopy core library in the classpath in order to make the "fork" attribute work for the Ant task
Jalopy now reformats (when enabled) Javadoc comments that only consist of a single @todo tag no matter before what code element a comment appears. The former behavior was to format Javadoc comments only when they appeared before class, interface, field, constructor or method declarations
Updated Forms to 1.0.3, oro to 2.0.8

1.0.1 (2003-12-31)

Adding spaces within parentheses may now be suppressed between parentheses with the same direction. See the White Space section in the manual for more information (#735618)
Multi-variables can now be automatically split. Refer to the Misc section in the manual for more information
New option that lets you keep line breaks of concatenated strings. See the Wrapping section in the manual for more information. Suggested by Richard Schulte
The attributes of XDoclet tags may now be indented to the level of the "." character in the name of the tag. See the Javadoc section in the manual for more information. Suggested by Craig Dickson
With Javadoc auto-correction enabled, it is now possible to suppress the checking when a @see tag is found. See the Javadoc section. Suggested by Elmar Sonnenschein
The User's manual now provides hints about the release version where a new feature was introduced

Bug fixes

The local variables $project$ and $project.desc$ were not interpolated. Reported by Elmar Sonnenschein
If a line break occurred directly after an assignment, the assignment expression was not indented when one was using endline indent
If an assignment expression started with a type cast but did not fit into the line, wrapping always happened after the assignment (not only when the "Always wrap after assignment when exceed" option was enabled)
No line wrapping was performed after type casts which could lead to cases where the line length limit was exceeded
When using endline indent, a multi-dimensional array that did not fit into one line had its first element not correctly indented. Reported by Elmar Sonnenschein
When the description text of a Javadoc standalone tag did not fit into a line but could not be wrapped because it contained no white space, Jalopy printed a line break between tag and description. Reported by Elmar Sonnenschein
Aligning of variable assignments did not always work correctly when "Align variable identifiers" was enabled, too. Reported by Elmar Sonnenschein
Wrapped assignment expressions were not always correctly indented when using the endline indent policy. Reported by Elmar Sonnenschein
"Align variable assignments" caused errors with multi-variables. Reported by Elmar Sonnenschein
Some more complicated dotted stuff like A.get().getC()[0].getD() could not be printed. Reported by Richard Schulte
After switching profiles, the environment variables were not updated. Reported by Elmar Sonnenschein
@jboss.create-table and @jboss.remove-table XDoclet tags were not recognized by the Javadoc parser. Reported by Craig Dickson
@ejb.permission and @ejb.transaction XDoclet tags were wrongly listed only in the class level table, they are valid on the method level also. Reported by Craig Dickson
Tidy Javadoc markup replaced certain characters (<, >, ", &, \) with their corresponding entities. This could lead to errors when one uses XDoclet tags to define EQL finders. Reported by Craig Dickson
For the Eclipse Plug-in it was not possible to use a Look&Feel implementation other than the default (another dreaded classloading problem). Reported by Bob McCune
Auto-insertion of Serial Version UID did not work for the Eclipse Plug-in. Reported by Byron Appelt
Expressions after the return statement were not correctly indented (not indented at all) with the standard indentation policy when wrapping occurred. Now the indentation level is correctly increased in such cases.
Please note that this has an impact on expressions surrounded by parentheses as indentation for such expressions will be increased one level, too.
Expressions not enclosed within parentheses like
```
return (modifierlistings & (Modifier.PUBLIC + Modifier.PROTECTED)) ==
0;
```
will become
```
return (modifierlistings & (Modifier.PUBLIC + Modifier.PROTECTED)) ==
    0;
```
And expressions inside parentheses like
```
return ("Checking the system state " +
    (isCheckSuccessful() ? "was successful" : "failed miserably"));
```
will become
```
return ("Checking the system state " +
        (isCheckSuccessful() ? "was successful" : "failed miserably"));
```
Blank lines setting for single-line comments did not always take effect (e.g. there was always at least one blank line printed for comments that appeared after variables). Reported by Jefferson Parke
With Javadoc standalone tag aligning enabled, tag descriptions for @param and @throws tags were not correctly indented when they started with an HTML tag
With Javadoc tag checking enabled, missing description text and tags were added even when the description only consisted of a single @see standalone tag or {@inheritDoc} inline tag. Reported by Elmar Sonnenschein
Tidy Javadoc markup always replaced HTML entities which could lead to errors when one uses entities to display strings that would otherwise not be allowed (like e.g. */ which translates to */)
When the Javadoc grouping tags feature was enabled, XDoclet tags for different containers were not separated by a blank line
When the "White space within method declaration" setting was enabled, but line wrapping disabled, two space characters were printed after left parentheses. Reported by Rich Polish
When the "White space within method declaration" setting was enabled and line breaks forced for all parameters of a method declaration, no blank space was printed after left parentheses
Extra blank line after the tag name added to XDoclet tags with multiple attributes when HTML markup checking was enabled. Reported by Craig Dickson
private static final fields incorrectly had JavaDoc added when generation for package protected (default access) level was enabled. Reported by Craig Dickson
The wrapping guide of the preview page did not consider the Javadoc wrapping line length when displaying preview in the Javadoc category

Changes

The integer values for the Javadoc generation mask changed. Your settings will be automatically updated when you start Jalopy. If you share your coding convention with others, you should re-export the convention using the graphical configuration dialog of the current release
There was always at least one blank line printed before multi-line comments that appeared after single-line or Javadoc comments. Now the appropriate blank line setting takes effect
There was always at least one blank line printed before single-line and Javadoc comments that appeared after multi-line and class/interface declarations. Now the appropriate blank line settings take effect

1.0 (2003-11-07)

IDEA Plug-in: Refer to the Plug-in section in the manual
Console Plug-in: new option --configure to invoke the graphical configuration dialog. The script to invoke the dialog has been abandoned
Console Plug-in: new option -l, --loglevel to specify logging level for message output
Console Plug-in: new option --look to specify the used Java Look&Feel
Console Plug-in: new option --nofail to specify that runs should not terminate when errors occur
Console Plug-in: new option -p, --project to temporarily activate a project
Console Plug-in: new option -q, --quiet to suppress noncritical messages
Console Plug-in: new option --test to perform formatting only in memory but not write output back to disk
Ant Plug-in: new attribute fork to perform formatting in a new JVM
Ant Plug-in: new attribute test to perform formatting only in memory but not write output back to disk
Ant Plug-in: new nested element variable to define an environment variable for the scope of a run
SQLJ support has been added. SQL clauses will be printed as-is with blank lines before and after as specified in the code convention. See the Blank Lines section in the manual
Blank lines can now be kept for all source elements and comments
Line breaks before operators and method declaration parameters or method call arguments can be kept. See the Wrapping section in the manual
The white space settings have been extended. See the White Space section in the manual
The sorting order of the elements in a group is now configurable. See the Sorting section in the manual
Headers/Footers may now only be inserted if not yet present. See the Header section in the manual
XDoclet Javadoc standalone tags are now supported. Special support for the Sun @beaninfo tag has been added. By default, the parser supports the tag set as of XDoclet 1.2 (see the Appendix). But you can define custom tags. See the Javadoc section
Javadoc comments are now permissible as header comments (Jalopy does not reformat such comments anymore)
The Javadoc parser has been completely rewritten. It now works under J2SE 1.4 and supports arbitrary HTML/XHTML tags. By default, the parser only understands HTML tags as of HTML 4.01. You need to define custom tags if you parse arbitrary content. See Javadoc section for more info
The Javadoc printer has been reworked. Many new features has been added. Comment checking and formatting has been made independent. See the Javadoc section in the manual
The Javadoc printer now supports the Jindent //JDOC- pragma comment way to indicate that no Javadoc comment should be generated for class/interface/field/constructor/method declarations. See the Comments section in the manual
Qualified identifiers and chained index operators (e.g. resultSetRow[ i ].field[ 0 ]) can now be wrapped
The graphical configuration dialog only stored information about the last settings page visited. Now it keeps track of the last visited tab, too
Synchronization of imported settings is now configurable and works for local files, too. See the Profiles section in the manual
Logging output may be stored in files. Output can be written using a custom text, simple XML or formatted HTML style. See the Messages section in the manual

Bug fixes

Jalopy had problems with certain bracketed expressions. Reported by Olivier Thomann (#759909)
Javadoc checking did not work for interfaces. Reported by Karsten Silz (#759692)
HTML lists were not always correctly printed and sometimes lost. Reported by David Garnier (#748202)
try/catch/finally block were not correctly printed with Sun brace style. Reported by John Hohlen (#745742)
Javadoc comment generation was not performed for elements with default access. Reported by Karsten Silz (#741016)
The configuration dialog could lock up when an invalid Javadoc template was specified. Reported by Scott R. Duchin and C. Peterson (#739251, #679795)
Method declarations that inadvertently declared the same exception twice in the throws clause caused an exception when Javadoc tag checking was enabled. Now, the repeated types are simply removed. Reported by Matthew R. Harrah (#732799)
It was not possible to add custom XDoclet tags via the graphical configuration tool. Reported by Dolf Starreveld (#731180)
An extraneous blank before the catch and finally keywords when using a certain custom brace style has been fixed. Reported by Dolf Starreveld (#731074)
Comments were erased in between array declarators. Reported by Leslie Currens (#730939)
Comments that appeared after an endline comment got lost. Reported by Marcel Offermans (#716697)
Selecting the GNU brace style did not indent as intended. Reported by Tom Tromey (#716393)
Javadoc line wrapping did not work for languages that does not use white space between words. Reported by Haihan Ji (#711518)
The jEdit Plug-in did not work. Reported by Jim Newsham (#710357, #701245, #658139)
Wrong blank line added for complicated multi-dimensional array declarations. Reported by Carsten Heyl (#706887)
E-Mail addresses in Javadoc caused errors. Reported by Hernan Otero (#705656)
The @linkplain tag was incorrectly printed as @linkPlain. Reported by Maarten Menken (#704869)
Console formatting using relative file paths could lead to file loss on errors because the backup copy could not be restored. Not only has this error been fixed but the formatting scheme changed that now all formatting is first done in memory, only on success Jalopy attempts to overwrite the original file. Reported by Carsten Heyl (#703623)
Comments before operators were not printed. Reported by Carsten Heyl (#703613, #703620)
Javadoc <pre> blocks were always prefixed with * (asterix). Jalopy now prints the blocks as-is. Reported by Jacques-Olivier Goussard (#702262)
When attempting to synchronize settings from a distributed location that were not accessible, Jalopy always used its default settings. Now it uses the current local settings as advertised. Reported by Daryl Robbins (#70160)
Empty parentheses were always printed with a blank space. This is now configurable. Reported by Bill Wallace (#698827)
The Javadoc parser still failed to parse   tags. Reported by Dong Che and Max Y. Kraynov (#687422, #660446)
The consistency check for Javadoc templates was too rigid. Reported by C. Peterson (#679795)
Code like String a = "abc" + (i = 100); could not be printed when endline indentation policy enabled. Reported by Alec Hothan (#678339)
Wrong indentation for 2-dimensional arrays. Reported by Ralph Warta (#675904)
Wrong indentation for array declarators that contained blank lines. Reported by Ralph Warta (#675902)
Endline comment after else wrongly printed with cuddle braces setting. Reported by Kees Kuip (#674570)
The Javadoc parser failed to parse custom Together tags. Reported by Mark Meuer (#673198)
Variable aligning failed for some rare cases. Reported by Torsten Lull (#656669)
Assignments that were split up by the + operator were wrongly printed with endline alignment policy. Reported by Grzegorz Pilarczyk (#656268)
User variables were not always interpolated. Reported and fixed by Venkatesh Prasad Ranganath (#656032)
Comments before array declarators were lost. Reported by Ralph Warta (#655455)
User variables could not be created due to a missing resource key. Reported by Dirk Möbius et.al. (#655646)
Comments within array declarators were removed. Reported by Ralph Warta (#655455)
/**/ was falsely recognized as Javadoc comment. Reported by Max Y. Kraynov (#655231)
Comments before instance initializers were not printed. Reported by Danny Sadinoff (#652057)
Javadoc paragraphs starting with inline tags were wrongly printed. Reported by Martin Saschek (#647734)
Fixed a bug in the imports optimization collapsing logic. Reported by Matt Lee (#646084)
Endline comments were wrongly printed for Sun brace style. Reported by Holger Danske (#646082)
Line wrapping offsets wrongly calculated in some boundary cases. The reported case and many, many more has been fixed, but this is still not perfect. Reported by Mirek Mocek (#645871)
Modifiers in the initialization part of for statements were not printed. Reported by Howard Lovatt (#643948)
For files with mixed line separators, the comment indenting could fail. Reported by Jari Kujansuu (#640637)
When using the endline indentation policy, Jalopy had problems with line breaks after shorthand assignments. Reported by Pierre Andrews (#640231)
Depending on the blank lines settings, too much blank lines were inserted before a block consisting of several comments. Reported by Kees Kuip (#639648)
On-demand wrapping "After parameters/expressions" only worked if "Wrap after left parenthesis" was enabled. Reported by Tim Moore (#639151)
The Javadoc parser is now more in line with the Javadoc "spec": the @ sign will be only recognized as the start of a standalone tag if encountered at the start of a line. Reported by Ken Gentle (#624817)
JBuilder Plug-in: the key binding for the editor action was re-defined on every program start, thus a custom binding was not persistent across program invocations. Additionally the binding was only defined for the currently active keymap, now the binding will be added to every keymap (when possible)
The popup menu (yes!) for text components (text fields, text areas...) did not show up under Linux
GNU brace style did not work for braces around statement lists in switch statements: the left curly brace was not indented
The info messages for auto-generated Javadoc tags (sometimes) contained wrong line information
Single line comments were not removed when "Remove single line comments" was enabled
Console Plug-in: the Plug-in did not report an error if it could not find the specified input file. If a qualified file path was specified, Jalopy did format the whole directory instead!
The setting "Blank lines before block" did not take effect if a label appeared before a block
The default Javadoc template for fields had a wrong value leading to uncompilable code in case Javadoc generation for fields was enabled and the template not changed by the user
Missing blank between Javadoc standalone tags and description when the description started with an inline tag. Reported by Dr. Mark Tu
Indentation before finally keyword wrongly printed if comments appeared before and Sun brace style was used
Semicolon after ternary operator expression was not indented if an endline comment appeared after the third operand
Indentation between label and following block was wrong if labels were not indented and no line break printed between label and block
Trailing blank space after label statements has been removed
Polished the Code Inspector; fixed some bugs (some checks did not work) and general ugliness

Changes

Jalopy is no longer developed under an Open Source license. Source code for restricted use is still available as part of a site license
Printing is now done in memory first in all cases (not only when checksum history feature was enabled). This aids security and avoids unnecessary disk I/O activity
Jalopy now uses heuristics considering blank lines to associate comments to source elements resulting in much better results. As a side effect, it is now possible to have Javadoc comments before the first and after the very last node of a source file (but the comments are then always printed as-is)
Multi-variables are no longer split automatically
The graphical configuration dialog has been completely overhauled. Many pages/options have been re-arranged. The GUI code now uses JGoodies Forms to achieve better consistency
The "Check tags" option now enables checking for all Javadoc tags. "Add thrown exceptions" was renamed to "Add @throws tags" and only adds exceptions that are actually thrown from within a constructor or method body
The GNU getopt library has been abandoned in favor of the BSD-ish Jakarta Commons CLI package
The validation of Javadoc templates is now less rigorous
The history comment feature is history
ANTLR updated to 2.7.2, oro updated to 2.0.7, log4j updated to 1.2.7
All third party libraries are now bundled to avoid classpath issues because of version conflicts

Prior releases

To learn about the changes in prior releases, follow the link below.

Old beta history »»

Release History Versions 1.0 - 1.4

1.4 (2004-12-20)

1.3 (2004-08-31)

1.2.1 (2004-07-05)

1.2 (2004-06-03)

1.1 (2004-05-06)

1.0.4 (2004-03-26)

1.0.3 (2004-03-12)

1.0.2 (2004-02-05)

1.0.1 (2003-12-31)

1.0 (2003-11-07)

Prior releases

Page Contents

What is Jalopy?

Who needs it?

I want some!

Learn the details

Release History Versions 1.0 - 1.4

1.4 (2004-12-20)

1.3 (2004-08-31)

1.2.1 (2004-07-05)

1.2 (2004-06-03)

1.1 (2004-05-06)

1.0.4 (2004-03-26)

1.0.3 (2004-03-12)

1.0.2 (2004-02-05)

1.0.1 (2003-12-31)

1.0 (2003-11-07)

Prior releases

Page Contents

Browse

What is Jalopy?

Who needs it?

I want some!

Learn the details