JDTUtils.java

/*******************************************************************************
 * Copyright (C) 2011 by Harry Blauberg
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ******************************************************************************/
package org.jaml.eclipse.utils;

import java.lang.reflect.InvocationTargetException;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.IProgressService;
import org.jaml.eclipse.Activator;

public class JDTUtils {

	public static List<IType> iterateJavaProjects() {
		List<IType> list = new LinkedList<IType>();
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IWorkspaceRoot wsRoot = workspace.getRoot();
		IProject[] projects = wsRoot.getProjects();
		for (IProject project : projects) {
			IJavaProject javaProject = JavaCore.create(project);
			if (javaProject != null) {
				try {
					list.addAll(findJavaTypes(javaProject));
				} catch (JavaModelException jme) {
					jme.printStackTrace();
				}
			}
		}
		return list;
	}

	public static List<IType> findJavaTypes(IJavaProject javaProject)
			throws JavaModelException {
		List<IType> list = new LinkedList<IType>();
		findJavaTypes(list, javaProject.getAllPackageFragmentRoots());
		return list;
	}

	public static void findJavaTypes(List<IType> list, IJavaElement[] elements)
			throws JavaModelException {
		for (IJavaElement element : elements) {
			findJavaTypes(list, element);
		}
	}

	public static void findJavaTypes(List<IType> list, IJavaElement element)
			throws JavaModelException {
		switch (element.getElementType()) {
		case IJavaElement.JAVA_PROJECT:
			// Java project
			IJavaProject proj = (IJavaProject) element;
			findJavaTypes(list, proj.getChildren());
			break;
		case IJavaElement.PACKAGE_FRAGMENT_ROOT:
			// JAR file
			IPackageFragmentRoot pkgRoot = (IPackageFragmentRoot) element;
			findJavaTypes(list, pkgRoot.getChildren());
			break;
		case IJavaElement.PACKAGE_FRAGMENT:
			// Java package
			IPackageFragment pkgFragment = (IPackageFragment) element;
			findJavaTypes(list, pkgFragment.getChildren());
			break;
		case IJavaElement.COMPILATION_UNIT:
			// Source file (.java)
			ICompilationUnit cmUnit = (ICompilationUnit) element;
			findJavaTypes(list, cmUnit.getTypes());
			break;
		case IJavaElement.CLASS_FILE:
			// Compiled file (.class)
			IClassFile clFile = (IClassFile) element;
			findJavaTypes(list, clFile.getType());
			break;
		case IJavaElement.TYPE:
			// Java class
			IType type = (IType) element;
			if (!type.getFullyQualifiedName().contains("$")) {
				list.add(type);
			}
			break;
		}
	}

	public static void sortTypeList(List<IType> types) {
		Collections.sort(types, new Comparator<IType>() {
			@Override
			public int compare(IType type1, IType type2) {
				return type1.getElementName().compareTo(type2.getElementName());
			}
		});
	}

	public static List<IType> filterByPackage(List<IType> types,
			String packageName) {
		List<IType> filteredTypes = new LinkedList<IType>();
		for (IType type : types) {
			if (type.getFullyQualifiedName().startsWith(packageName)) {
				filteredTypes.add(type);
			}
		}
		return filteredTypes;
	}

	public static List<String> getListOfProperties(IType type) {
		try {
			List<IMethod> allMethods = new LinkedList<IMethod>();
			fetchMethods(allMethods, type);
			return getListOfProperties(allMethods);
		} catch (JavaModelException e) {
			// Deliver empty list
			return new LinkedList<String>();
		}
	}

	public static void fetchMethods(List<IMethod> list, IType type)
			throws JavaModelException {
		if (type != null) {
			// Fetch all methods from current type
			for (IMethod method : type.getMethods()) {
				list.add(method);
			}
			// Get superclass
			IType superClassType = getITypeByName(Activator.getDefault()
					.getAvailableTypes(), type.getSuperclassName());
			fetchMethods(list, superClassType);
			// Get super interfaces
			String[] superInterfaces = type.getSuperInterfaceNames();
			IType superInterfaceType = null;
			for (String superInterface : superInterfaces) {
				superInterfaceType = getITypeByName(Activator.getDefault()
						.getAvailableTypes(), superInterface);
				fetchMethods(list, superInterfaceType);
			}
		}
	}

	public static IType getITypeByName(List<IType> list, String fQN) {
		for (IType type : list) {
			if (type.getFullyQualifiedName().equals(fQN)) {
				return type;
			}
		}
		return null;
	}

	public static List<String> getListOfProperties(Iterable<IMethod> methods) {
		List<String> listOfGetters = new LinkedList<String>();
		List<String> listOfSetters = new LinkedList<String>();
		String name = null;
		String attrName = null;
		for (IMethod method : methods) {
			name = method.getElementName();
			if (name.length() > 3) {
				attrName = name.substring(3);
				if (name.startsWith("get")) {
					listOfGetters.add(attrName);
				} else if (name.startsWith("set")) {
					listOfSetters.add(attrName);
				} else if (name.startsWith("is")) {
					listOfGetters.add(name.substring(2));
				}
			}
		}
		// Keep only the property names which are in the setters list, too
		listOfGetters.retainAll(listOfSetters);
		// Convert to set, because sets cannot have duplicates
		listOfGetters = new LinkedList<String>(new HashSet<String>(
				listOfGetters));
		// Sort list
		Collections.sort(listOfGetters);
		return listOfGetters;
	}

	public static List<String> getTypesByAttr(IType type, String attribute)
			throws JavaModelException {
		List<String> types = new LinkedList<String>();
		List<IMethod> methods = new LinkedList<IMethod>();
		fetchMethods(methods, type);
		String tmp = null;
		for (IMethod method : methods) {
			if (method.getElementName().equals("set" + attribute)) {
				if (method.getParameterTypes().length == 1) {
					tmp = method.getParameterTypes()[0];
					tmp = (tmp.startsWith("L") && tmp.endsWith(";")) ? tmp
							.substring(1, tmp.length() - 1) : tmp;
					/*
					 * method.getTypeRoot().findPrimaryType().getFullyQualifiedName
					 * () tmp = + tmp;
					 */
					if (!types.contains(tmp)) {
						types.add(tmp);
					}
				}
			}
		}
		return types;
	}

	public static List<String> getAlreadyUsedAttrs(IDocument doc,
			int documentOffset) throws BadLocationException {
		List<String> attrList = new LinkedList<String>();
		StringBuilder bld = new StringBuilder();
		String returnVal = null;
		String[] attrs = null;
		int startPos = documentOffset - 2;
		char letter = '?';
		while (startPos > 0) {
			letter = doc.getChar(startPos);
			if (letter == '<') {
				returnVal = bld.toString();
				attrs = returnVal.split(" ");
				for (int i = 1; i < attrs.length; i++) {
					attrList.add(attrs[i].split("=")[0].trim());
				}
				return attrList;
			}
			bld.insert(0, letter);
			startPos--;
		}
		return null;
	}

	public static boolean checkDocToChars(IDocument doc, int offset,
			String letters) throws BadLocationException {
		return checkDocToChars(doc, offset, letters.toCharArray());
	}

	public static boolean checkDocToChars(IDocument doc, int offset,
			char... letters) throws BadLocationException {
		for (int i = 0; i < letters.length; i++) {
			if (doc.getChar(offset - (i + 1)) != letters[i]) {
				return false;
			}
		}
		return true;
	}

	public static String getLastAttribute(IDocument doc, int documentOffset)
			throws BadLocationException {
		StringBuilder bld = new StringBuilder();
		String returnVal = null;
		int startPos = documentOffset - 2;
		char letter = '?';
		while (startPos > 0) {
			letter = doc.getChar(startPos);
			if (letter == ' ') {
				returnVal = bld.toString();
				return returnVal.contains("=") ? returnVal.split("=")[0]
						: returnVal;
			}
			bld.insert(0, letter);
			startPos--;
		}
		return null;
	}

	public static IType getITypeFromTag(String tag) {
		List<IType> list = Activator.getDefault().getAvailableTypes();
		for (IType type : list) {
			if (type.getElementName().equals(tag)) {
				return type;
			}
		}
		return null;
	}

	public static String getLastTag(IDocument doc, int documentOffset)
			throws BadLocationException {
		StringBuilder bld = new StringBuilder();
		String returnVal = null;
		int startPos = documentOffset - 2;
		char letter = '?';
		while (startPos > 0) {
			letter = doc.getChar(startPos);
			if (letter == '<') {
				returnVal = bld.toString();
				return returnVal.contains(" ") ? returnVal.split(" ")[0]
						: returnVal;
			}
			bld.insert(0, letter);
			startPos--;
		}
		return null;
	}

	public static String getProposalPartBeforeCursor(String text) {
		return "<" + text + ">";
	}

	public static String getProposalPartAfterCursor(String text) {
		return "</" + text + ">";
	}

	public static String getQualifier(IDocument doc, int documentOffset) {
		// Use string buffer to collect characters
		StringBuffer buf = new StringBuffer();
		while (true) {
			try {
				// Read character backwards
				char c = doc.getChar(--documentOffset);
				// This was not the start of a tag
				if (c == '>' || Character.isWhitespace(c)) {
					return "";
				}
				// Collect character
				buf.append(c);
				// Start of tag. Return qualifier
				if (c == '<') {
					return buf.reverse().toString();
				}
			} catch (BadLocationException e) {
				// Document start reached, no tag found
				return "";
			}
		}
	}

	public static void loadAllTypes(final List<IType> list) {
		invokeLongTask(new IRunnableWithProgress() {
			@Override
			public void run(IProgressMonitor monitor)
					throws InvocationTargetException, InterruptedException {
				monitor.setTaskName("JAML");
				monitor.beginTask("Collecting JAML classes...", 2);
				list.addAll(JDTUtils.iterateJavaProjects());
				monitor.internalWorked(1);
				JDTUtils.sortTypeList(list);
				monitor.internalWorked(2);
				monitor.done();
			}
		});
	}

	public static Exception invokeLongTask(IRunnableWithProgress runnable) {
		try {
			getProgressSvc().busyCursorWhile(runnable);
			return null;
		} catch (Exception e) {
			return e;
		}
	}

	public static IProgressService getProgressSvc() {
		return PlatformUI.getWorkbench().getProgressService();
	}

	public static String getIJavaElementPath(IJavaElement element)
			throws JavaModelException {
		switch (element.getElementType()) {
		case IJavaElement.JAVA_PROJECT:
			return element.getCorrespondingResource().getFullPath().toString();
		case IJavaElement.PACKAGE_FRAGMENT_ROOT:
			return element.getCorrespondingResource().getFullPath().toString();
		case IJavaElement.PACKAGE_FRAGMENT:
			return element.getCorrespondingResource().getFullPath().toString();
		case IJavaElement.COMPILATION_UNIT:
			return element.getCorrespondingResource().getFullPath().toString()
					.replace(element.getElementName(), "");
		case IJavaElement.TYPE:
			return getIJavaElementPath(element.getParent());
		}
		return JavaExt.STRING_EMPTY;
	}
}