For fun - a poor man's code beautifier

[Carey Brown]

Time and time again I see Java beginners not taking the time to clean up their code before posting it so I whipped up this very rudimentary code beautifier "Indentify". My beautifier of choice is the Eclipse IDE but most beginners haven't gotten to the point of using IDEs yet.  Maybe, just maybe, this will help someone out and make our collective lives easier.

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;

/**
 * A (very) poor man's Java code beautifier.
 * Indentation levels only governed by the use of braces.
 * No braces - no indent.
 * Indent is 4 spaces (not tabs)
 * Limits blank lines to only one at a time.
 * Puts each brace on its own line.
 * 
 * This will handle about 90% of the clean up task but you
 * surely will have some hand tweaking that will be needed
 * afterwards.
 *
 * Usage: java Indentify *.java
 */
public class Indentify
{
	private static final String		NL = System.getProperty( "line.separator" );
	private static final String		SPACES; // used for creating leading line indentation
	
	static
	{
		StringBuilder		sb = new StringBuilder();
		for( int i=0 ; i < 256 ; i++ )
			sb.append( ' ' );
		SPACES = sb.toString();
	}
	
	public static void main( String[] args )
	{
		for( String fname : args )
		{
			try
			{
				System.out.println( "Indentifying: " + fname );
				String			fileString = readFile( fname );
				List<Token>		tokens = tokenize( fileString );
//				debug( tokens );
				output( fname, tokens );
			}
			catch( Exception ex )
			{
				ex.printStackTrace();
			}
		}
		System.out.println( "Output in \".pretty\" files." );
		System.out.println( "Done." );
	}

	private static String readFile( String fname )
	throws FileNotFoundException, IOException
	{
		StringBuilder		fileString = new StringBuilder();
		String				s;
		try( BufferedReader in = new BufferedReader( new FileReader( fname ) ) )
		{
			while( (s = in.readLine()) != null )
			{
				fileString.append( s + '\n' );
			}
		}
		return fileString.toString().replaceAll( "\\s*[\n]\\s*([\n]\\s*)+", "\n\n" );
	}
	
	private static List<Token> tokenize( String fileString )
	{
		List<Token>			tokens = new ArrayList<>();
		Type				type = Type.TEXT;
		Type				newType = type;
		StringBuilder		sb2 = new StringBuilder();
		
		for( int i=0 ; i < fileString.length() ; i++ )
		{
			char	c = fileString.charAt( i );
			
			switch( type )
			{
			case TEXT:
				newType = type;
				if( c == '/' && i < fileString.length()-1
						&& fileString.charAt( i+1 ) == '/' )
				{
					newType = Type.SLASH_COMMENT;
				}
				else if( c == '/' && i < fileString.length()-1
						&& fileString.charAt( i+1 ) == '*' )
				{
					newType = Type.STAR_COMMENT;
				}
				else if( c == '"' )
				{
					newType = Type.STRING_CONSTANT;
				}
				else if( c == '\n' )
				{
					newType = Type.NEW_LINE;
				}
				else if( c == '{' )
				{
					newType = Type.OPEN_BRACE;
				}
				else if( c == '}' )
				{
					newType = Type.CLOSE_BRACE;
				}
				
				if( newType != type )
				{
					add( tokens, type, sb2 );
					type = newType;
				}
				
				sb2.append( c );
				break;
				
			case STRING_CONSTANT:
				sb2.append( c );
				if( c == '\\' )
				{
					sb2.append( fileString.charAt( i+1 ) );
					i++;
				}
				else if( c == '"' )
				{
					add( tokens, type, sb2 );
					type = Type.TEXT;
				}
				break;
				
			case SLASH_COMMENT:
				if( c == '\n' )
				{
					add( tokens, type, sb2 );
					add( tokens, Type.NEW_LINE, NL );
					type = Type.TEXT;
				}
				else
				{
					sb2.append( c );
				}
				break;
				
			case STAR_COMMENT:
			case STAR_COMMENT_CONTINUED:
				if( c == '*' && i < fileString.length()-1
					&& fileString.charAt( i+1 ) == '/' )
				{
					sb2.append( "*/" );
					i++;
					add( tokens, type, sb2 );
					type = Type.TEXT;
				}
				else if( c == '\n' )
				{
					add( tokens, type, sb2 );
					add( tokens, Type.NEW_LINE, NL );
					type = Type.STAR_COMMENT_CONTINUED;
				}
				else
				{
					sb2.append( c );
				}
				break;
				
			case OPEN_BRACE:
			case CLOSE_BRACE:
				boolean		flg = false;
				if( c == ';' )
				{
					flg = true;
					sb2.append( ';' ); // for array initializers = {...};
				}
				add( tokens, type, sb2 );
				type = Type.TEXT;
				if( ! flg )
					i--;
				break;
				
			case NEW_LINE:
				add( tokens, Type.NEW_LINE, NL );
				sb2.delete( 0, sb2.length() );
				i--;
				type = Type.TEXT;
				break;
			} // switch(type)
		} // foreach character in fileString
		
		add( tokens, type, sb2 );
		
		return tokens;
	} // tokenize
	
	private static void add( List<Token> tokens, Type type, String str )
	{
		if( str.length() > 0 )
		{
			tokens.add( new Token( type, str ) );
		}
	}
	
	private static void add( List<Token> tokens, Type type, StringBuilder sb )
	{
		String		s = sb.toString().trim();
		if( s.length() > 0 )
		{
			tokens.add( new Token( type, s ) );
			sb.delete( 0, sb.length() );
		}
	}
	
	private static void output( String fname, List<Token> tokens )
	throws FileNotFoundException
	{
		fname += ".pretty";
		try( PrintStream out = new PrintStream( fname ) )
		{
			int			level = 0;
			Type		prevType = Type.NEW_LINE;
			Type		nextType = Type.NEW_LINE;
			Type		type;
			
			for( int i=0 ; i < tokens.size() ; i++ )
			{
				Token tk = tokens.get( i );
				type = tk.type;
				if( i < tokens.size()-1 )
					nextType = tokens.get( i+1 ).type;
				else
					nextType = Type.NEW_LINE;
				
				switch( type )
				{
				case TEXT:
					out.print( tk.str );
					break;
					
				case STRING_CONSTANT:
					out.print( tk.str );
					break;
					
				case SLASH_COMMENT:
					if( prevType != Type.NEW_LINE )
						out.print( "  " );
					out.print( tk.str );
					break;
					
				case STAR_COMMENT:
					out.print( tk.str );
					break;
					
				case STAR_COMMENT_CONTINUED:
					out.print( indent( level ) );
					out.print( tk.str );
					break;
					
				case OPEN_BRACE:
					if( prevType != Type.NEW_LINE )
					{
						out.print( NL );
						out.print( indent( level ) );
					}
					out.print( tk.str );
					level++;
					if( nextType != Type.NEW_LINE )
					{
						out.print( NL );
						type = Type.NEW_LINE;
						if( nextType != Type.NEW_LINE )
							out.print( indent( level ) );
					}
					break;
					
				case CLOSE_BRACE:
					if( prevType != Type.NEW_LINE )
						out.print( NL );
					level--;
					if( level < 0 )
						level = 0;
					out.print( indent( level ) );
					out.print( tk.str );
					if( nextType != Type.NEW_LINE )
					{
						out.print( NL );
						type = Type.NEW_LINE;
						if( nextType != Type.NEW_LINE  && nextType != Type.CLOSE_BRACE )
							out.print( indent( level ) );
					}
					break;
					
				case NEW_LINE:
					out.print( tk.str );
					if( nextType != Type.NEW_LINE && nextType != Type.CLOSE_BRACE )
						out.print( indent( level ) );
					break;
				} // switch(type)
				
				prevType = type;
				
			} // foreach token
		} // try with resources
	} // output
	
	private static void debug( List<Token> tokens )
	{
		for( Token tk : tokens )
			System.out.println( tk );
	}
	
	private static String indent( int n )
	{
		return SPACES.substring( 0, n * 4 );
	}
}

enum Type { TEXT, STRING_CONSTANT, SLASH_COMMENT, STAR_COMMENT,
	STAR_COMMENT_CONTINUED, OPEN_BRACE, CLOSE_BRACE, NEW_LINE };

class Token
{
	Type		type;
	String		str;
	
	public Token( Type type, String str )
	{
		this.type = type;
		this.str = str;
	}
	
	// used for debugging
	public String toString()
	{
		return String.format( "%22s  %s",
			type, (type != Type.NEW_LINE ? str : "") );
	}
}

[Michael Billiot]

I tend to do something like shown below for the beginning { and ending }...
But the most important question is "Did you use spaces or tabs?"

LOL

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;

/**
 *
 * @author Michael
 */
public class Checkers extends Application {
    public static final int TILE_SIZE = 100;
    public static final int WIDTH = 8;
    public static final int HEIGHT = 8;
    private Group tileGroup = new Group();
    private Group pieceGroup  = new Group();
	
    private Parent createContent() {
		Pane root = new Pane();
		root.setPrefSize(WIDTH*TILE_SIZE, HEIGHT*TILE_SIZE);
		root.getChildren().addAll(tileGroup, pieceGroup);
		
		for (int y = 0; y < HEIGHT; y ++) {
            for (int x = 0; x < HEIGHT; x ++ ) {
				Tile tile = new Tile((x + y ) % 2 == 0 , x , y);
				tileGroup.getChildren().add(tile);
				Piece piece  = null;
				if(y <= 2 && (x + y ) % 2 != 0) {
                    piece = makePiece(PieceType.RED, x, y);
				}
				
				if(y >= 5 && (x + y ) % 2 != 0) {
                    piece = makePiece(PieceType.WHITE, x, y);
				}
		
                if (piece != null) {
				}
				
				if(piece != null) {
                    tile.setPiece(piece);
                    pieceGroup.getChildren().add(piece);
				}
            }
        }
	
        return root;
    }
	
    @Override
    public void start(Stage primaryStage) throws Exception {
		Scene scene = new Scene(createContent());
		primaryStage.setTitle("Checkers");
		primaryStage.setScene(scene);
		primaryStage.show();
    }
	
    private Piece makePiece(PieceType type, int x, int y) {
		Piece piece = new Piece(type, x, y);
		return piece;
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
		launch(args);
    }	
}

[Carey Brown]

Michael Billiot wrote:I tend to do something like shown below for the beginning { and ending }...
But the most important question is "Did you use spaces or tabs?"
LOL

Four spaces (not tabs) per indent level. Would be trivial to substitute tabs if you wanted.

Ah, yes. K&R style. Depending on my audience, I've used both. I find the "one brace over the other" style to be helpful to beginners. It was also easier to make a beautifier for.

[Tim Holloway]

Actually, I used Jalopy (http://jalopy.sourceforge.net), which actually blows away the built-in IDE beautifiers when it come to customization. It ran stand-alone or as a plug-in to most popular IDEs. Could even be set up to do batch processing to enforce formatting on entire projects.

Originally, and in the SourceForge version, it was free software. It seems to have been converted to commercial software now ($40/seat). And it may be orphaned entirely now, alas - last update seems to have been in 2010.

[Carey Brown]

The Downloads section of the link you provided gives a 404 error.

[Tim Holloway]

Carey Brown wrote:The Downloads section of the link you provided gives a 404 error.

He moved it to github - there's a link (jalopy2).

Although I'm not sure exactly what the project builds - most of what I saw in there was interface code, not anything that looked like parsing and formatting.