package org.eclipse.jdt.core.formatter;

/*

 *  These numbers need to be here so that the formatter application can check if

 *  the specified formatter config file is compatible. 

 * 

 */

public class ProfileVersionNumbers {

	private ProfileVersionNumbers() { /* shouldn't be instantiated */ }

	public static final int VERSION_1= 1; // < 20040113 (includes M6)

	public static final int VERSION_2= 2; // before renaming almost all

	public static final int VERSION_3= 3; // after renaming almost all

	public static final int VERSION_4= 4; 

	public static final int VERSION_5= 5; // after splitting of FORMATTER_INDENT_BLOCK_STATEMENTS

	public static final int VERSION_6= 6; // after splitting of new_line_in_control_statements

	public static final int VERSION_7= 7; // after moving comment formatter to JDT Core

	public static final int VERSION_8= 8; // fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=89739

	public static final int VERSION_9= 9; // after storing project profile names in preferences

	public static final int CURRENT_VERSION= VERSION_9;

}

/*******************************************************************************

 * Copyright (c) 2004 Ben Konrath <ben@bagu.org>

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Ben Konrath <ben@bagu.org> - initial implementation

 *******************************************************************************/

CommandLine.start=Starting format job ...

CommandLine.done=Done.

CommandLine.config.file=Configuration Name: {0}

CommandLine.formatting=Formatting: {0}

CommandLine.usage=Usage: {0} [ OPTIONS ] <files>

CommandLine.files=<files>

CommandLine.files.msg1=Java source files and/or directories to format.

CommandLine.files.msg2=Only files ending with {0} will be formatted in the given directory.

CommandLine.options=OPTIONS:

CommandLine.config={0} <file>

CommandLine.config.msg1=Use the formatting style from the specified config file.

CommandLine.config.msg2=This file must be an xml file that has been exported by Eclipse 3.0.

CommandLine.help=Display this message.

CommandLine.quiet=Only print error messages.

CommandLine.verbose=Be verbose about the formatting job.

CommandLineError.file={0} does not exsit. Please specify only valid Java Source files.

CommandLineError.config=There was problem reading the config file, {0}.

CommandLineError.file.dir=You must specify at least one file or dirctory to format.

CommandLineError.quiet.verbose=You cannot use the options {0} and {1} together.

Exception.io=Caught IOExecption:

Exception.bad.location=Caught BadLocationException:  

Exception.skip=Skipping File.

ConfigFile.reading.error=Error Reading config file.

Edit.problem=The Eclipse formatter had a problem {0}, Skipping.

/*******************************************************************************

 * Copyright (c) 2004 Ben Konrath <ben@bagu.org>

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Ben Konrath <ben@bagu.org> - initial implementation

 *     Red Hat Incorporated - add ProfileVersionNumbers.CURRENT_VERSION

 *******************************************************************************/

package org.eclipse.jdt.core.formatter;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Writer;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.eclipse.core.runtime.IPlatformRunnable;

import org.eclipse.core.runtime.Platform;

import org.eclipse.jdt.core.ToolFactory;

import org.eclipse.jdt.internal.core.util.Util;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.IDocument;

import org.eclipse.text.edits.TextEdit;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

/**

 * Class that handles the org.eclipse.jdt.core.JavaCodeFormatter the

 * application. The map file reading code is based on code in ProfileStore.java

 * (org.eclipse.jdf.ui).

 * 

 * There are a couple improvments that could be made:

 * 1. Add an import clean up option (requires stuff from org.eclipse.jdt.ui).

 * 2. Make a list of all the files first so that a file does not get formatted twice.

 * 3. Use a text based progress monitor for output.

 * 4. Allow using/updating older versions of the formatter config file. This requires

 *    a largish refactor because ProfilerVersioner is tied to the 

 *    org.eclipse.jdt.internal.ui.preferences code which is tied to several UI plugins.

 * 

 * @author Ben Konrath <ben@bagu.org>

 */

public class CodeFormatterApplication implements IPlatformRunnable {

    /**

     * A SAX event handler to parse the config xml.

     */

    private final static class ConfigHandler extends DefaultHandler {

        /**

         * Identifiers for the XML file.

         */

        private final String XML_NODE_ROOT = "profiles"; //$NON-NLS-1$

        private final String XML_NODE_PROFILE = "profile"; //$NON-NLS-1$

        private final String XML_NODE_SETTING = "setting"; //$NON-NLS-1$

        private final String XML_ATTRIBUTE_VERSION = "version"; //$NON-NLS-1$

        private final String XML_ATTRIBUTE_ID = "id"; //$NON-NLS-1$

        private final String XML_ATTRIBUTE_NAME = "name"; //$NON-NLS-1$

        private final String XML_ATTRIBUTE_VALUE = "value"; //$NON-NLS-1$

        private int fVersion;

        private String fName;

        private Map fSettings;

        public void startElement(String uri, String localName, String qName,

                Attributes attributes) throws SAXException {

            if (qName.equals(XML_NODE_SETTING)) {

                final String key = attributes.getValue(XML_ATTRIBUTE_ID);

                final String value = attributes.getValue(XML_ATTRIBUTE_VALUE);

                fSettings.put(key, value);

            } else if (qName.equals(XML_NODE_PROFILE)) {

                fName = attributes.getValue(XML_ATTRIBUTE_NAME);

                fSettings = new HashMap(200);

            } else if (qName.equals(XML_NODE_ROOT)) {

                try {

                    fVersion = Integer.parseInt(attributes

                            .getValue(XML_ATTRIBUTE_VERSION));

                } catch (NumberFormatException ex) {

                    throw new SAXException(ex);

                }

            }

        }

        public Map getSettings() {

            return fSettings;

        }

        public int getVersion() {

            return fVersion;

        }

        public String getName() {

            return fName;

        }

    }

    /**

     * Deals with the messages in the properties file (cut n' pasted from a

     * generated class).

     */

    private final static class FormatterAppMessages {

        private static final String BUNDLE_NAME = "org.eclipse.jdt.core.formatter.FormatterAppMessages";//$NON-NLS-1$

        private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle

                .getBundle(BUNDLE_NAME);

        public static String getString(String key) {

            try {

                return RESOURCE_BUNDLE.getString(key);

            } catch (MissingResourceException e) {

                return '!' + key + '!';

            }

        }

        public static String getFormattedString(String key, String arg) {

            return getFormattedString(key, new String[] { arg });

        }

        public static String getFormattedString(String key, String[] args) {

            return MessageFormat.format(getString(key), args);

        }

    }

    /**

     * Read the xml config file and return a Map representing the options that

     * are in the specified config file.

     */

    public Map readConfig(String filename) {

        try {

            final FileInputStream reader = new FileInputStream(new File(

                    filename));

            final ConfigHandler handler = new ConfigHandler();

            try {

                InputSource inputSource = new InputSource(reader);

                final SAXParserFactory factory = SAXParserFactory.newInstance();

                final SAXParser parser = factory.newSAXParser();

                parser.parse(inputSource, handler);

                if (handler.getVersion() != ProfileVersionNumbers.CURRENT_VERSION)

                    return null;

                configName = handler.getName();

                return handler.getSettings();

            } finally {

                try { reader.close(); } catch (IOException e) { /* ignore */ }

            }

        } catch (IOException e) {

            Util.log(e, FormatterAppMessages

                    .getString("ConfigFile.reading.error")); //$NON-NLS-1$

        } catch (SAXException e) {

            Util.log(e, FormatterAppMessages

                    .getString("ConfigFile.reading.error")); //$NON-NLS-1$

        } catch (ParserConfigurationException e) {

            Util.log(e, FormatterAppMessages

                    .getString("ConfigFile.reading.error")); //$NON-NLS-1$

        }

        return null;

    }

    /**

     * Runs the Java code formatter application

     */

    public Object run(Object args) throws Exception {

        ArrayList fileList = processCommandLine((String[]) args);

        // nothing to do

        if (fileList == null || fileList.isEmpty())

        	return EXIT_OK;

        if (!quiet) {

        	if (configName != null)

        		System.out.println(FormatterAppMessages.getFormattedString("CommandLine.config.file", configName)); //$NON-NLS-1$

            System.out.println(FormatterAppMessages.getString("CommandLine.start")); //$NON-NLS-1$

        }

        // format the list of files and/or directories

        while (!fileList.isEmpty()) {

        	File file = (File) fileList.remove(0);

            if (file.isDirectory())

                formatDirTree(file);

            else

                formatFile(file);    

        }

        if (!quiet) {

            System.out.println(FormatterAppMessages.getString("CommandLine.done")); //$NON-NLS-1$

        }

        return EXIT_OK;

    }

    private void displayHelp(String message) {

        System.err.println(message);

        System.out.println(""); //$NON-NLS-1$

        displayHelp();

    }

    private String configName;

    /*

     * The output will look like this:

     * 

     * "Usage: eclipse -application org.eclipse.jdt.core.JavaCodeFormatter [ OPTIONS ] <files>

     *     <files>		Java source files and/or directories to format.

     *					Only files ending with .java will be formatted in the given directory.

     *  OPTIONS:

     *	   -config <file>		Use the formatting style from the specified config file.

     *							This file must be an xml file that has been exported by Eclipse 3.0.

     *     -help				Display this message.

     *     -quiet				Only print error messages.

     *	   -verbose				Be verbose about the formatting job.   

     */

    private void displayHelp() {

        String binaryName = Platform.getOS().equals(Platform.OS_WIN32) ? "eclipse.exe" : "eclipse"; //$NON-NLS-1$ //$NON-NLS-2$

        // this is UG-LY. is there a way to make this look nicer?

        System.out.println(FormatterAppMessages.getFormattedString("CommandLine.usage", //$NON-NLS-1$

        		binaryName + " -application org.eclipse.jdt.core.JavaCodeFormatter")); //$NON-NLS-1$

        System.out.println(""); //$NON-NLS-1$

        System.out.println("   " + FormatterAppMessages.getString("CommandLine.files") //$NON-NLS-1$ //$NON-NLS-2$

                + "\t" + FormatterAppMessages.getString("CommandLine.files.msg1")); //$NON-NLS-1$ //$NON-NLS-2$

        System.out.println("\t\t" //$NON-NLS-1$

        		+ FormatterAppMessages.getFormattedString("CommandLine.files.msg2", ".java")); //$NON-NLS-1$ //$NON-NLS-2$ 

        System.out.println(FormatterAppMessages.getString("CommandLine.options")); //$NON-NLS-1$

        System.out.println("   " + FormatterAppMessages.getFormattedString("CommandLine.config", ARG_CONFIG) //$NON-NLS-1$ //$NON-NLS-2$ 

        		+ "\t" + FormatterAppMessages.getString("CommandLine.config.msg1")); //$NON-NLS-1$ //$NON-NLS-2$

        System.out.println("\t\t\t" + FormatterAppMessages.getString("CommandLine.config.msg2")); //$NON-NLS-1$ //$NON-NLS-2$

        System.out.println("   " + ARG_HELP + "\t\t" + FormatterAppMessages.getString("CommandLine.help")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        System.out.println("   " + ARG_QUIET + "\t\t" + FormatterAppMessages.getString("CommandLine.quiet")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        System.out.println("   " + ARG_VERBOSE +"\t\t" + FormatterAppMessages.getString("CommandLine.verbose")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ 

    }

    private final String ARG_HELP =    "-help"; //$NON-NLS-1$

    private final String ARG_CONFIG =  "-config"; //$NON-NLS-1$

    private final String ARG_VERBOSE = "-verbose"; //$NON-NLS-1$

    private final String ARG_QUIET = "-quiet"; //$NON-NLS-1$

    private boolean verbose = false;

    private boolean quiet = false;

    private ArrayList processCommandLine(String[] argsArray) {

        ArrayList args = new ArrayList();

        for (int i = 0; i < argsArray.length; i++) {

			args.add(argsArray[i]);

		}

        // look for flag-like args

        if (args.remove(ARG_HELP)) {

            displayHelp();

            return null;

        }

        if (args.remove(ARG_VERBOSE))

            verbose = true;

        if (args.remove(ARG_QUIET)) 

        	quiet = true;

        if (quiet && verbose) {

        	displayHelp(FormatterAppMessages.getFormattedString

        			("CommandLineError.quiet.verbose", new String[] {ARG_QUIET, ARG_VERBOSE})); //$NON-NLS-1$

        	return null;

        }

        args.remove("-pdelaunch"); //$NON-NLS-1$

        // look for flag/param args

        int index = args.indexOf(ARG_CONFIG);

        if (index >= 0) {

            args.remove(index);

            String configFile = (String) args.remove(index);

            options = readConfig(configFile);

            if (options == null) {

                displayHelp(FormatterAppMessages

                        .getFormattedString("CommandLineError.config", configFile)); //$NON-NLS-1$

                return null;

            }

        }

        // only the files and directories should remain

        ArrayList fileList = new ArrayList();

        while (!args.isEmpty()) {

			String fileName = (String) args.remove(0);

			File file = new File(fileName);

			if (file.exists()) {

				fileList.add(file);

			} else {

				displayHelp(FormatterAppMessages

					.getFormattedString("CommandLineError.file", fileName)); //$NON-NLS-1$

				return null;

			}

		}

        if (fileList.isEmpty())

        	displayHelp(FormatterAppMessages.getString("CommandLineError.file.dir")); //$NON-NLS-1$

        return fileList;

    }

    /**

     * Recursively format the Java source code that is contained in the

     * directory rooted at dir.

     */

    private void formatDirTree(File dir) {

        File[] files = dir.listFiles();

        if (files == null)

            return;

        for (int i = 0; i < files.length; i++) {

            File file = files[i];

            if (file.isDirectory()) {

                formatDirTree(file);

            } else if (file.getPath().endsWith(".java")) { //$NON-NLS-1$

                formatFile(file);

            }

        }

    }

    // internal representation of configuration options in the xml file

    private Map options = null;

    /**

     * Format the given Java source file.

     */

    private void formatFile(File file) {

        IDocument doc = new Document();

        try {

            // read the file

            final BufferedReader in = new BufferedReader(new FileReader(file));

            if (verbose) {           

                System.out.println(FormatterAppMessages.getFormattedString

                		("CommandLine.formatting", file.getName())); //$NON-NLS-1$

            }

            String line;

            String contents = ""; //$NON-NLS-1$

            try {

                while ((line = in.readLine()) != null)

                    contents = contents

                            + System.getProperty("line.separator") + line; //$NON-NLS-1$

            } finally {

                try { in.close(); } catch (IOException e) { /* ignore */  }

            }

            // format the file (the meat and potatoes)

            doc.set(contents);

            TextEdit edit = ToolFactory.createCodeFormatter(options).format(

                    CodeFormatter.K_COMPILATION_UNIT, doc.get(), 0,

                    doc.getLength(), 0, null);

            if (edit != null) {

                edit.apply(doc);

            } else {            	

                System.err.println

                	(FormatterAppMessages.getFormattedString("Edit.problem", file.getName())); //$NON-NLS-1$

                return;

            }

            // write the file

            final Writer out = new BufferedWriter(new FileWriter(file, false));

            try {

                out.write(doc.get());

                out.flush();

            } finally {

                try { out.close(); } catch (IOException e) { /* ignore */ }

            }

        } catch (IOException e) {

            String errorMessage = FormatterAppMessages.getString("Exception.io") + " " //$NON-NLS-1$ //$NON-NLS-2$

            	+ e.getLocalizedMessage();

            Util.log(e, errorMessage);

            System.err.println(errorMessage); 

            System.err.println(FormatterAppMessages.getString("Exception.skip")); //$NON-NLS-1$

        }  catch (BadLocationException e) {

            String errorMessage = FormatterAppMessages.getString("Exception.bad.location") + " " //$NON-NLS-1$ //$NON-NLS-2$

    			+ e.getLocalizedMessage();

            Util.log(e, errorMessage);

            System.err.println(errorMessage); 

            System.err.println(FormatterAppMessages.getString("Exception.skip")); //$NON-NLS-1$

        }

    }

}

import org.eclipse.jdt.core.formatter.ProfileVersionNumbers;

import org.eclipse.jdt.core.formatter.ProfileVersionNumbers;

import org.eclipse.jdt.core.formatter.ProfileVersionNumbers;

import org.eclipse.jdt.core.formatter.ProfileVersionNumbers;