[Skip to content]

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 <p> with <br> tags after paragraphs without the optional </p>
    /**
     * <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 <br /> were printed as <br>. 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. &#042;&#047; 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 <br/> 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 »»

What is Jalopy?

Jalopy is a world-class source code formatter for Java. It automates and enforces all aspects of source code layout—to meet a certain coding style without putting any burden on individual developers.

Learn more

Who needs it?

Jalopy is for everyone involved with source code editing. It scales from single developer usage to large scale enterprise deployment and seamlessly integrates with your favorite Java IDE or build tool.

Go and see yourself

I want some!

Concentrate on your problem domain and don’t waste time shuffling characters around. Pricing starts at USD $40 for a single-user license. Buy now using secure online purchase or wire transfer.

What are you waiting for?

Learn the details

Deploy, configure and use the software to best meet your needs. Download the printable user’s guide and learn everything there is to know to put Jalopy’s advanced feature set to full use.

Download (.pdf - 7.2MB)