plugins/org.eclipse.gmf.xpand.migration/src/org/eclipse/gmf/internal/xpand/migration/ui/BuildPropertiesManager.java

/**
 * Copyright (c) 2009 Borland Software Corp.
 * 
 * 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:
 *    Alexander Shatalin (Borland) - initial API and implementation
 */
package org.eclipse.gmf.internal.xpand.migration.ui;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.StringTokenizer;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.gmf.internal.xpand.migration.Activator;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.pde.core.build.IBuildEntry;
import org.eclipse.text.edits.InsertEdit;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.ReplaceEdit;

public class BuildPropertiesManager {

	private static final String BUILD_PROPERTIES = "build.properties";

	private static final String PROPERTY_JAR_ORDER = "jars.compile.order";

	private static final String DEFAULT_JAR_NAME = ".";

	private static final String DEFAULT_LIBRARY_ENTRY = IBuildEntry.JAR_PREFIX + DEFAULT_JAR_NAME;

	/** Copied from {@link org.eclipse.pde.internal.core.util.PropertiesUtil} */
	private static final char[] HEX = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	private IProject project;

	private List<IFolder> sourceFolders = new ArrayList<IFolder>();

	private List<IResource> binInclude = new ArrayList<IResource>();

	private IFile buildPropertiesFile;

	/** Copied from {@link org.eclipse.pde.internal.core.util.PropertiesUtil} */
	private static String createWritableName(String source) {
		if (source.indexOf(' ') >= 0) {
			// has blanks
			StringBuffer writableName = new StringBuffer();
			for (int i = 0; i < source.length(); i++) {
				char c = source.charAt(i);
				if (c == ' ') {
					writableName.append("\\ "); //$NON-NLS-1$
				} else
					writableName.append(c);
			}
			source = writableName.toString();
		}
		return createEscapedValue(source);
	}

	/** Copied from {@link org.eclipse.pde.internal.core.util.PropertiesUtil} */
	public static String createEscapedValue(String value) {
		// if required, escape property values as \\uXXXX
		StringBuffer buf = new StringBuffer(value.length() * 2);
		// assume expansion by less than factor of 2
		for (int i = 0; i < value.length(); i++) {
			char character = value.charAt(i);
			if (character == '\\' || character == '\t' || character == '\r' || character == '\n' || character == '\f') {
				// handle characters requiring leading \
				buf.append('\\');
				buf.append(character);
			} else if ((character < 0x0020) || (character > 0x007e)) {
				// handle characters outside base range (encoded)
				buf.append('\\');
				buf.append('u');
				buf.append(HEX[(character >> 12) & 0xF]); // first nibble
				buf.append(HEX[(character >> 8) & 0xF]); // second nibble
				buf.append(HEX[(character >> 4) & 0xF]); // third nibble
				buf.append(HEX[character & 0xF]); // fourth nibble
			} else {
				// handle base characters
				buf.append(character);
			}
		}
		return buf.toString();
	}

	/** Copied from {@link org.eclipse.pde.internal.core.util.PropertiesUtil} */
	public static int getInsertOffset(IDocument doc) {
		int offset = doc.getLength();
		for (int i = doc.getNumberOfLines() - 1; i >= 0; i--) {
			try {
				if (doc.get(doc.getLineOffset(i), doc.getLineLength(i)).trim().length() > 0) {
					break;
				}
				offset = doc.getLineOffset(i);
			} catch (BadLocationException e) {
			}
		}
		return offset;
	}

	// TODO: move to the shared static MigrationUtils class
	private static CoreException createCoreException(Throwable th) {
		return new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Exception during migration", th));
	}

	private static CoreException createCoreException(String message) {
		return new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, message));
	}

	// TODO: move to the shared static MigrationUtils class
	private static IProgressMonitor createSubProgressMonitor(IProgressMonitor monitor, String taskName, int numberOfTicks) throws InterruptedException {
		if (monitor.isCanceled()) {
			throw new InterruptedException("Process was canceled");
		}
		SubProgressMonitor spm = new SubProgressMonitor(monitor, numberOfTicks);
		if (taskName != null) {
			spm.setTaskName(taskName);
		}
		return spm;
	}

	public BuildPropertiesManager(IProject project) {
		this.project = project;
	}

	public void addSourceFolder(IFolder sourceFolder) {
		sourceFolders.add(sourceFolder);
	}

	public void addBinInclude(IResource resource) {
		binInclude.add(resource);
	}

	public void save(IProgressMonitor monitor) throws CoreException, InterruptedException {
		if (sourceFolders.isEmpty() && binInclude.isEmpty()) {
			monitor.done();
			return;
		}
		monitor.beginTask("Saving modified " + BUILD_PROPERTIES + " file", 6);
		Properties buildProperties = loadBuildProperties();
		monitor.worked(1);
		IDocument document = loadDocument(getBuildPropertiesFile());
		String lf = TextUtilities.getDefaultLineDelimiter(document);
		monitor.worked(1);
		MultiTextEdit edit = new MultiTextEdit();
		addSourceFolders(edit, document, buildProperties, lf);
		monitor.worked(1);
		addBinIncludes(edit, document, buildProperties, lf);
		monitor.worked(1);
		try {
			edit.apply(document);
		} catch (MalformedTreeException e) {
			createCoreException(e);
		} catch (BadLocationException e) {
			createCoreException(e);
		}
		monitor.worked(1);
		saveDocument(document, getBuildPropertiesFile(), createSubProgressMonitor(monitor, "Saving modified " + BUILD_PROPERTIES + " file", 1));
	}

	private void addBinIncludes(MultiTextEdit edit, IDocument document, Properties buildProperties, String lf) throws CoreException {
		List<String> binIncludes = getValues(buildProperties, IBuildEntry.BIN_INCLUDES);
		for (IResource resource : binInclude) {
			IPath projectRelativePath = resource.getProjectRelativePath();
			if (resource instanceof IFolder) {
				projectRelativePath = projectRelativePath.addTrailingSeparator();
			}
			binIncludes.add(projectRelativePath.toString());
		}
		modifyKey(IBuildEntry.BIN_INCLUDES, binIncludes, edit, document, buildProperties, lf);
	}

	private void addSourceFolders(MultiTextEdit edit, IDocument document, Properties buildProperties, String lf) throws CoreException {
		List<String> jarOrderValues = getValues(buildProperties, PROPERTY_JAR_ORDER);
		if (!jarOrderValues.contains(DEFAULT_JAR_NAME)) {
			jarOrderValues.add(DEFAULT_JAR_NAME);
			modifyKey(PROPERTY_JAR_ORDER, jarOrderValues, edit, document, buildProperties, lf);
		}
		List<String> defaultLibraryFolders = getValues(buildProperties, DEFAULT_LIBRARY_ENTRY);
		for (IFolder nextFolder : sourceFolders) {
			defaultLibraryFolders.add(nextFolder.getProjectRelativePath().addTrailingSeparator().toString());
		}
		modifyKey(DEFAULT_LIBRARY_ENTRY, defaultLibraryFolders, edit, document, buildProperties, lf);
	}

	private void modifyKey(String key, List<String> values, MultiTextEdit edit, IDocument document, Properties buildProperties, String lf) throws CoreException {
		String text = serialize(values, key, lf);
		if (buildProperties.containsKey(key)) {
			int offset = getKeyOffset(document, key);
			int length = getKeyLength(document, key, offset);
			edit.addChild(new ReplaceEdit(offset, length, text));
		} else {
			edit.addChild(new InsertEdit(getInsertOffset(document), text));
		}
	}

	/**
	 * Similar to
	 * {@link org.eclipse.pde.internal.core.text.build.Build#adjustOffsets()}
	 */
	private int getKeyLength(IDocument document, String key, int keyOffset) {
		int lines = document.getNumberOfLines();
		try {
			for (int i = 0; i < lines; i++) {
				int offset = document.getLineOffset(i);
				if (offset < keyOffset) {
					continue;
				}
				int length = document.getLineLength(i);
				String line = document.get(offset, length);
				if (line.startsWith("#") | line.startsWith("!")) {
					return offset - 1 - keyOffset;
				}

				line = line.trim();
				if (line.length() == 0) {
					return offset - 1 - keyOffset;
				}
				if (!line.endsWith("\\")) {
					return offset + document.getLineLength(i) - keyOffset;
				}
			}
		} catch (BadLocationException e) {
			// should never be here
		}
		return document.getLength() - keyOffset;
	}

	/**
	 * Similar to
	 * {@link org.eclipse.pde.internal.core.text.build.Build#adjustOffsets()}
	 */
	private int getKeyOffset(IDocument document, String key) throws CoreException {
		try {
			int lines = document.getNumberOfLines();
			for (int i = 0; i < lines; i++) {
				int offset = document.getLineOffset(i);
				int length = document.getLineLength(i);
				String line = document.get(offset, length);
				if (line.startsWith("#") | line.startsWith("!")) {
					continue;
				}
				line = line.trim();
				int index = line.indexOf('=');
				if (index == -1) {
					continue;
				}
				String name = line.substring(0, index).trim();
				if (createEscapedValue(key).equals(name)) {
					while (Character.isSpaceChar(document.getChar(offset))) {
						offset += 1;
					}
					return offset;
				}
			}
		} catch (BadLocationException e) {
			// should never be here
		}
		assert false;
		throw createCoreException("Property: " + key + " was not found in " + BUILD_PROPERTIES + " file");
	}

	/**
	 * Copied from
	 * {@link org.eclipse.pde.internal.core.text.build.BuildEntry#write()}
	 */
	private String serialize(List<String> values, String propertyName, String lf) {
		StringBuffer buffer = new StringBuffer();
		buffer.append(createWritableName(propertyName));
		buffer.append(" = "); //$NON-NLS-1$
		int indentLength = propertyName.length() + 3;
		for (int i = 0; i < values.size(); i++) {
			buffer.append(createEscapedValue(values.get(i)));
			if (i < values.size() - 1) {
				buffer.append(",\\"); //$NON-NLS-1$
				buffer.append(lf);
				for (int j = 0; j < indentLength; j++) {
					buffer.append(" "); //$NON-NLS-1$
				}
			}
		}
		buffer.append(lf);
		return buffer.toString();
	}

	private List<String> getValues(Properties buildProperties, String key) {
		List<String> values = new ArrayList<String>();
		if (!buildProperties.containsKey(key)) {
			return values;
		}
		StringTokenizer stok = new StringTokenizer(buildProperties.getProperty(key).toString(), ","); //$NON-NLS-1$
		while (stok.hasMoreTokens()) {
			values.add(stok.nextToken().trim());
		}
		return values;
	}

	private IDocument loadDocument(IFile file) throws CoreException {
		if (!file.exists()) {
			return new Document();
		}
		try {
			Reader reader = new InputStreamReader(buildPropertiesFile.getContents(), file.getCharset());
			StringBuilder currentLine = new StringBuilder();
			for (char nextChar = (char) reader.read(); nextChar != (char) -1; nextChar = (char) reader.read()) {
				currentLine.append(nextChar);
			}
			return new Document(currentLine.toString());
		} catch (IOException e) {
			throw createCoreException(e);
		}
	}

	private void saveDocument(IDocument document, IFile file, IProgressMonitor monitor) throws CoreException {
		// TODO: check if it works correctly
		String charset = file.exists() ? file.getCharset() : "ISO-8859-1";
		try {
			InputStream inputStream = new ByteArrayInputStream(document.get().getBytes(charset));
			if (buildPropertiesFile.exists()) {
				buildPropertiesFile.setContents(inputStream, IFile.FORCE | IFile.KEEP_HISTORY, monitor);
			} else {
				buildPropertiesFile.create(inputStream, true, monitor);
			}
		} catch (UnsupportedEncodingException e) {
			throw createCoreException(e);
		}
	}

	private Properties loadBuildProperties() throws CoreException {
		Properties result = new Properties();
		if (getBuildPropertiesFile().exists()) {
			try {
				result.load(getBuildPropertiesFile().getContents());
			} catch (IOException e) {
				throw createCoreException(e);
			}
		}
		return result;
	}

	private IFile getBuildPropertiesFile() {
		if (buildPropertiesFile == null) {
			buildPropertiesFile = project.getFile(BUILD_PROPERTIES);
		}
		return buildPropertiesFile;
	}

}