/*******************************************************************************
* Copyright (c) 2012 Pivotal Software, Inc.
* 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:
* Pivotal Software, Inc. - initial API and implementation
*******************************************************************************/
package org.grails.ide.eclipse.editor.groovy.elements;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.eclipse.core.model.GroovyProjectFacade;
import org.codehaus.jdt.groovy.model.GroovyCompilationUnit;
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.resources.IResourceVisitor;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
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.jdt.internal.core.ClassFile;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.util.Util;
import org.grails.ide.eclipse.core.GrailsCoreActivator;
import org.grails.ide.eclipse.core.internal.GrailsNature;
import org.grails.ide.eclipse.core.internal.plugins.GrailsCore;
import org.grails.ide.eclipse.core.internal.plugins.GrailsElementKind;
import org.grails.ide.eclipse.core.model.GrailsVersion;
import org.grails.ide.eclipse.core.workspace.internal.GrailsProjectUtil;
import org.grails.ide.eclipse.editor.groovy.types.PerProjectTypeCache;
/**
* A Grails project and provides access to all grails elements managed by this project.
* Create using {@link GrailsWorkspaceCore}.
* @author Andrew Eisenberg
* @author Christian Dupuis
* @author Nieraj Singh
* @created Nov 23, 2009
*/
@SuppressWarnings("nls")
public class GrailsProject {
private final IJavaProject javaProject;
private GroovyProjectFacade groovyProject;
private Map<String, IGrailsElement> classNodeGrailsElementCache = new HashMap<String, IGrailsElement>();
protected GrailsProject(IJavaProject javaProject) {
this.javaProject = javaProject;
}
/**
* converts to a lowercase name. Not exactly right. Could be
* a problem if name starts with a double capital.
* @param type
* @return
*/
public static String getBeanName(IType type) {
String typeName = type.getElementName();
typeName = typeName.substring(0, 1).toLowerCase() + typeName.substring(1);
return typeName;
}
public GroovyProjectFacade getGroovyProject() {
if (groovyProject == null) {
groovyProject = new GroovyProjectFacade(javaProject);
}
return groovyProject;
}
/**
* Converts this {@link ICompilationUnit} into a {@link GrailsElementKind} if
* it corresponds to a standard Grails artifact. Otherwise returns {@link GrailsElementKind#OTHER}.
* Returns {@link GrailsElementKind#INVALID} if compilation unit is not from this Project or compilation unit
* is not from a grails project.
* @param unit
* @return
*/
public GrailsElementKind getElementKind(ICompilationUnit unit) {
if (unit == null || (! unit.getJavaProject().equals(javaProject))) {
return GrailsElementKind.INVALID;
}
if (! (unit instanceof GroovyCompilationUnit)) {
return GrailsElementKind.OTHER;
}
IPackageFragmentRoot root = ((CompilationUnit) unit).getPackageFragmentRoot();
String rootName = root.getElementName();
if (GrailsElementKind.CONTROLLER_CLASS.getSourceFolder().equals(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.CONTROLLER_CLASS;
} else {
return GrailsElementKind.OTHER;
}
} else if (GrailsElementKind.DOMAIN_CLASS.getSourceFolder().equals(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.DOMAIN_CLASS;
} else {
return GrailsElementKind.OTHER;
}
} else if (GrailsElementKind.TAGLIB_CLASS.getSourceFolder().equals(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.TAGLIB_CLASS;
} else {
return GrailsElementKind.OTHER;
}
} else if (GrailsElementKind.SERVICE_CLASS.getSourceFolder().equals(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.SERVICE_CLASS;
} else {
return GrailsElementKind.OTHER;
}
} else if (GrailsElementKind.INTEGRATION_TEST.getSourceFolder().equals(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.INTEGRATION_TEST;
} else {
return GrailsElementKind.OTHER;
}
} else if (GrailsElementKind.UNIT_TEST.getSourceFolder().endsWith(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.UNIT_TEST;
} else {
return GrailsElementKind.OTHER;
}
} else if (GrailsElementKind.INTEGRATION_TEST.getSourceFolder().endsWith(rootName)) {
if (primaryTypeExists(unit)) {
return GrailsElementKind.INTEGRATION_TEST;
} else {
return GrailsElementKind.OTHER;
}
} else if (rootName.equals(GrailsElementKind.CONF_FOLDER)) {
String elementName = unit.getElementName();
if (GrailsElementKind.BOOT_STRAP.getNameSuffix().equals(elementName)) {
return GrailsElementKind.BOOT_STRAP;
} else if (GrailsElementKind.BUILD_CONFIG.getNameSuffix().equals(elementName)) {
return GrailsElementKind.BUILD_CONFIG;
} else if (GrailsElementKind.CONFIG.getNameSuffix().equals(elementName)) {
return GrailsElementKind.CONFIG;
} else if (GrailsElementKind.DATA_SOURCE.getNameSuffix().equals(elementName)) {
return GrailsElementKind.DATA_SOURCE;
} else if (GrailsElementKind.URL_MAPPINGS.getNameSuffix().equals(elementName)) {
return GrailsElementKind.URL_MAPPINGS;
}
// only for testing
} else if (cuHandleToElementKind.containsKey(unit.getHandleIdentifier())) {
return cuHandleToElementKind.get(unit.getHandleIdentifier());
}
return GrailsElementKind.OTHER;
}
private IType getPrimaryType(ICompilationUnit unit) {
IType primaryType = unit.getType(getPrimaryTypeName(unit));
return primaryType != null && primaryType.exists() ? primaryType : null;
}
/**
* @param unit
* @return true iff the primary type (that is the type whose name matches the compilation unit)
* exists
*/
private boolean primaryTypeExists(ICompilationUnit unit) {
return getPrimaryType(unit) != null;
}
protected String getPrimaryTypeName(ICompilationUnit unit) {
String elementName = unit.getElementName();
// we already know that this unit ends with .groovy, so no need to check
return Util.getNameWithoutJavaLikeExtension(elementName);
}
public ControllerClass getControllerClass(GroovyCompilationUnit unit) {
if (getElementKind(unit) == GrailsElementKind.CONTROLLER_CLASS) {
return new ControllerClass(unit);
}
return null;
}
public ServiceClass getServiceClass(IType target) {
IJavaElement cu = target.getAncestor(IJavaElement.COMPILATION_UNIT);
if (cu instanceof GroovyCompilationUnit) {
GroovyCompilationUnit gcu = (GroovyCompilationUnit) cu;
return getServiceClass(gcu);
}
return null;
}
public TestClass getTestClass(IType target) {
IJavaElement cu = target.getAncestor(IJavaElement.COMPILATION_UNIT);
if (cu instanceof GroovyCompilationUnit) {
GroovyCompilationUnit gcu = (GroovyCompilationUnit) cu;
return getTestClass(gcu);
}
return null;
}
public ControllerClass getControllerClass(IType target) {
IJavaElement cu = target.getAncestor(IJavaElement.COMPILATION_UNIT);
if (cu instanceof GroovyCompilationUnit) {
GroovyCompilationUnit gcu = (GroovyCompilationUnit) cu;
return getControllerClass(gcu);
}
return null;
}
public DomainClass getDomainClass(String packageName, String domainName) {
return (DomainClass) getGrailsElement(packageName, domainName, GrailsElementKind.DOMAIN_CLASS.getSourceFolder(), GrailsElementKind.DOMAIN_CLASS);
}
public ServiceClass getServiceClass(String packageName, String serviceName) {
return (ServiceClass) getGrailsElement(packageName, serviceName, GrailsElementKind.SERVICE_CLASS.getSourceFolder(), GrailsElementKind.SERVICE_CLASS);
}
public TestClass getTestClass(String packageName, String testName) {
TestClass result = (TestClass) getGrailsElement(packageName, testName, GrailsElementKind.UNIT_TEST.getSourceFolder(), GrailsElementKind.UNIT_TEST);
if (result == null) {
result = (TestClass) getGrailsElement(packageName, testName, GrailsElementKind.INTEGRATION_TEST.getSourceFolder(), GrailsElementKind.INTEGRATION_TEST);
}
return result;
}
public ControllerClass getControllerClass(String packageName, String controllerName) {
return (ControllerClass) getGrailsElement(packageName, controllerName, GrailsElementKind.CONTROLLER_CLASS.getSourceFolder(), GrailsElementKind.CONTROLLER_CLASS);
}
public TagLibClass getTagLibClass(String packageName, String tagLibName) {
return (TagLibClass) getGrailsElement(packageName, tagLibName, GrailsElementKind.TAGLIB_CLASS.getSourceFolder(), GrailsElementKind.TAGLIB_CLASS);
}
private IGrailsElement getGrailsElement(String packageName, String elementName, String locationString, GrailsElementKind kind) {
String fullName;
if (packageName.length() > 0) {
fullName = "grails-app/" + locationString + "/" + packageName.replace('.', '/') + "/" + elementName;
} else {
fullName = "grails-app/" + locationString + "/" + elementName;
}
IFile file = javaProject.getProject().getFile(fullName);
ICompilationUnit cUnit = JavaCore.createCompilationUnitFrom(file);
if (cUnit instanceof GroovyCompilationUnit && cUnit.exists()) {
switch (kind) {
case DOMAIN_CLASS:
return getDomainClass((GroovyCompilationUnit) cUnit);
case CONTROLLER_CLASS:
return getControllerClass((GroovyCompilationUnit) cUnit);
case SERVICE_CLASS:
return getServiceClass((GroovyCompilationUnit) cUnit);
case TAGLIB_CLASS:
return getTagLibClass((GroovyCompilationUnit) cUnit);
case UNIT_TEST:
return getTestClass((GroovyCompilationUnit) cUnit);
case INTEGRATION_TEST:
return getTestClass((GroovyCompilationUnit) cUnit);
}
}
return null;
}
/**
* Finds a controller class if it exists when the package is not known
* @param name
* @return
*/
public ControllerClass getControllerClass(String name) {
return (ControllerClass) getGrailsElement(name, GrailsElementKind.CONTROLLER_CLASS);
}
/**
* Gets a grails element when the package is not known.
* Will scan all packages in the appropriate source folder and
* look for compilation units with the given name. If more than
* one of that name exists, but in different folders, then an arbitrary one
* is returned.
*
* Will return null if no unit of the given name exists
*/
private IGrailsElement getGrailsElement(String name, GrailsElementKind kind) {
if (!name.endsWith(".groovy")) {
name = name+".groovy";
}
// currently only implement for Controller class
if (kind != GrailsElementKind.CONTROLLER_CLASS) {
return null;
}
try {
IPackageFragmentRoot root = javaProject.findPackageFragmentRoot(new Path("/" + javaProject.getElementName() + "/grails-app/controllers"));
if (root == null) {
return null;
}
IJavaElement[] children = root.getChildren();
for (IJavaElement child : children) {
if (child instanceof IPackageFragment) {
IPackageFragment frag = (IPackageFragment) child;
ICompilationUnit unit = frag.getCompilationUnit(name);
if (unit.exists() && unit instanceof GroovyCompilationUnit) {
return new ControllerClass((GroovyCompilationUnit) unit);
}
}
}
} catch (JavaModelException e) {
GrailsCoreActivator.log(e);
}
return null;
}
public TagLibClass getTagLibClass(GroovyCompilationUnit cUnit) {
return new TagLibClass(cUnit);
}
public DomainClass getDomainClass(GroovyCompilationUnit unit) {
if (getElementKind(unit) == GrailsElementKind.DOMAIN_CLASS) {
return new DomainClass(unit);
}
return null;
}
public ServiceClass getServiceClass(GroovyCompilationUnit unit) {
if (getElementKind(unit) == GrailsElementKind.SERVICE_CLASS) {
return new ServiceClass(unit);
}
return null;
}
public TestClass getTestClass(GroovyCompilationUnit unit) {
if (getElementKind(unit) == GrailsElementKind.UNIT_TEST ||
getElementKind(unit) == GrailsElementKind.INTEGRATION_TEST) {
return new TestClass(unit);
}
return null;
}
public IGrailsElement getGrailsElement(ICompilationUnit unit) {
GrailsElementKind kind = getElementKind(unit);
switch (kind) {
case DOMAIN_CLASS:
return new DomainClass((GroovyCompilationUnit) unit);
case CONTROLLER_CLASS:
return new ControllerClass((GroovyCompilationUnit) unit);
case TAGLIB_CLASS:
return new TagLibClass((GroovyCompilationUnit) unit);
case SERVICE_CLASS:
return new ServiceClass((GroovyCompilationUnit) unit);
case UNIT_TEST:
return new TestClass((GroovyCompilationUnit) unit);
case INTEGRATION_TEST:
return new TestClass((GroovyCompilationUnit) unit);
case BUILD_CONFIG:
case BOOT_STRAP:
case CONFIG:
case DATA_SOURCE:
case URL_MAPPINGS:
return new GenericConfigElement((GroovyCompilationUnit) unit, kind);
case INVALID:
return new InvalidGrailsElement();
}
return new OtherGrailsElement(unit);
}
public IGrailsElement getGrailsElement(IType type) {
ICompilationUnit cu = type.getCompilationUnit();
if (cu!=null) {
if (cu.getElementName().equals(type.getElementName()+".groovy")) {
return getGrailsElement(cu);
}
}
return null;
}
/**
* Finds the compilation unit of the type being completed
* will return null if the completion type is binary
* @param context
* @return
*/
private ICompilationUnit getUnit(ClassNode completionType) {
IType type = getGroovyProject().groovyClassToJavaType(completionType);
return type != null && !type.isBinary() ? type.getCompilationUnit() : null;
}
/**
* create a grails element from a groovy class node
* @param clazz
* @return the corresponding grails element. Will never return null, but
* may return {@link InvalidGrailsElement}.
*/
public IGrailsElement getGrailsElement(ClassNode clazz) {
String classQualifiedName = clazz.getName();
if (classNodeGrailsElementCache.containsKey(classQualifiedName)) {
return classNodeGrailsElementCache.get(classQualifiedName);
}
ICompilationUnit unit = getUnit(clazz);
IGrailsElement elt = getGrailsElement(unit);
classNodeGrailsElementCache.put(classQualifiedName, elt);
return elt;
}
public List<TagLibClass> getCustomTagLibClasses() {
IFolder folder = javaProject.getProject().getFolder("grails-app/taglib");
List<TagLibClass> taglibs = findTagLibClassesInFolder(folder);
return taglibs;
}
/**
* @param folder
* @return
*/
private List<TagLibClass> findTagLibClassesInFolder(IFolder folder) {
List<TagLibClass> taglibs = new ArrayList<TagLibClass>();
if (folder.exists()) {
try {
IPackageFragmentRoot root = (IPackageFragmentRoot) JavaCore.create(folder);
if (root != null && root.exists()) {
for (IJavaElement elt : root.getChildren()) {
if (elt.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
IPackageFragment pack = (IPackageFragment) elt;
ICompilationUnit[] units = pack.getCompilationUnits();
for (ICompilationUnit unit : units) {
if (unit instanceof GroovyCompilationUnit && unit.getElementName().endsWith("TagLib.groovy")) {
taglibs.add(getTagLibClass((GroovyCompilationUnit) unit));
}
}
} else if (elt.getElementType() == IJavaElement.COMPILATION_UNIT) {
ICompilationUnit unit = (ICompilationUnit) elt;
if (unit instanceof GroovyCompilationUnit && unit.getElementName().endsWith("TagLib.groovy")) {
taglibs.add(new TagLibClass((GroovyCompilationUnit) unit));
}
}
}
} else {
GrailsCoreActivator.log("Problem when looking for tag libraries:\n" +
folder.getLocation().toOSString() + " is not a source folder.",
new RuntimeException());
}
} catch (JavaModelException e) {
GrailsCoreActivator.log("Exception when trying to get all taglib classes for " + javaProject.getElementName(), e);
}
}
return taglibs;
}
/**
* Returns all TagLibs supplied by plugins
* @return
*/
public List<TagLibClass> getPluginTagLibClasses() {
try {
IClasspathEntry[] entries = javaProject.getRawClasspath();
List<TagLibClass> taglibs = new ArrayList<TagLibClass>();
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
for (IClasspathEntry entry : entries) {
switch (entry.getEntryKind()) {
case IClasspathEntry.CPE_SOURCE:
if (isPluginTagLibSourceFolder(entry.getPath())) {
IFolder folder = root.getFolder(entry.getPath());
if (folder.isAccessible()) {
taglibs.addAll(findTagLibClassesInFolder(folder));
}
}
break;
default:
break;
}
}
return taglibs;
} catch (JavaModelException e) {
GrailsCoreActivator.log("Problem creating tag libraries from plugins", e);
}
return Collections.emptyList();
}
public List<IProject> getDependentGrailsProjects() {
try {
return GrailsProjectUtil.getDependentGrailsProjects(javaProject);
} catch (JavaModelException e) {
GrailsCoreActivator.log("Problem creating tag libraries from plugins", e);
}
return Collections.EMPTY_LIST;
}
public Map<String, ClassNode> findAllServices() throws JavaModelException {
PerProjectTypeCache typeCache = GrailsCore.get().connect(javaProject.getProject(), PerProjectTypeCache.class);
if (typeCache != null) {
return internalFindGrailsElementsForProject(typeCache, javaProject, GrailsElementKind.SERVICE_CLASS);
} else {
return Collections.emptyMap();
}
}
/**
* @return a map of all controllers in the current grails project, including those coming
* from plugins. The key of the map is the controller name as a bean name (ie- simple name of
* class with first letter lower case with the
*
* @throws JavaModelException
*/
public Map<String, ClassNode> findAllControllers() throws JavaModelException {
PerProjectTypeCache typeCache = GrailsCore.get().connect(javaProject.getProject(), PerProjectTypeCache.class);
if (typeCache != null) {
return internalFindGrailsElementsForProject(typeCache, javaProject, GrailsElementKind.CONTROLLER_CLASS);
} else {
return Collections.emptyMap();
}
}
private Map<String, ClassNode> internalFindGrailsElementsForProject(PerProjectTypeCache typeCache, IJavaProject thisProject, GrailsElementKind kind)
throws JavaModelException {
Map<String, ClassNode> grailsElementMap = new HashMap<String, ClassNode>();
IClasspathEntry[] rawEntries = thisProject.getRawClasspath();
for (IClasspathEntry entry : rawEntries) {
// this may not capture services in plugins because the source folder is linked
if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE && entry.getPath().lastSegment().equals(kind.getSourceFolder())) { //$NON-NLS-1$
IPackageFragmentRoot root = thisProject.findPackageFragmentRoot(entry.getPath());
if (root == null) continue; // something is wrong with this project
// all CUs that end in Service are services
IJavaElement[] frags = root.getChildren();
for (IJavaElement elt : frags) {
if (elt instanceof IPackageFragment) {
IPackageFragment frag = (IPackageFragment) elt;
ICompilationUnit[] units = frag.getCompilationUnits();
for (ICompilationUnit unit : units) {
if (unit instanceof GroovyCompilationUnit && unit.getElementName().endsWith(kind.getNameSuffix())) { //$NON-NLS-1$
IType graileElementType = getPrimaryType(unit);
if (graileElementType != null) {
grailsElementMap.put(getBeanName(graileElementType), typeCache.getClassNode(graileElementType.getFullyQualifiedName()));
}
}
}
}
}
} else if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
// trawl through dependent grails projects
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().lastSegment());
if (GrailsNature.isGrailsPluginProject(project)) {
IJavaProject otherProject = JavaCore.create(project);
grailsElementMap.putAll(internalFindGrailsElementsForProject(typeCache, otherProject, kind));
}
}
}
return grailsElementMap;
}
public IType findControllerFromSimpleName(String name) throws JavaModelException {
return internalFindGrailsElementTypeForProject(Character.toUpperCase(name.charAt(0)) + name.substring(1) + "Controller", GrailsCore.get().connect(javaProject.getProject(), PerProjectTypeCache.class), javaProject, GrailsElementKind.CONTROLLER_CLASS);
}
private IType internalFindGrailsElementTypeForProject(String primaryTypeName, PerProjectTypeCache typeCache, IJavaProject thisProject, GrailsElementKind kind)
throws JavaModelException {
String unitName = primaryTypeName + ".groovy";
IClasspathEntry[] rawEntries = thisProject.getRawClasspath();
for (IClasspathEntry entry : rawEntries) {
// this may not capture services in plugins because the source folder is linked
if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE && entry.getPath().lastSegment().equals(kind.getSourceFolder())) { //$NON-NLS-1$
IPackageFragmentRoot root = thisProject.findPackageFragmentRoot(entry.getPath());
if (root == null) continue; // something is wrong with this project
// all CUs that end in Service are services
IJavaElement[] frags = root.getChildren();
for (IJavaElement elt : frags) {
if (elt instanceof IPackageFragment) {
IPackageFragment frag = (IPackageFragment) elt;
ICompilationUnit[] units = frag.getCompilationUnits();
for (ICompilationUnit unit : units) {
if (unit instanceof GroovyCompilationUnit && unit.getElementName().equals(unitName)) { //$NON-NLS-1$
IType grailsElementType = unit.getType(primaryTypeName);
if (grailsElementType.exists()) {
return grailsElementType;
}
}
}
}
}
} else if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
// trawl through dependent grails projects
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().lastSegment());
if (GrailsNature.isGrailsPluginProject(project)) {
IJavaProject otherProject = JavaCore.create(project);
IType type = internalFindGrailsElementTypeForProject(primaryTypeName, typeCache, otherProject, kind);
if (type != null) {
return type;
}
}
}
}
return null;
}
private boolean isPluginTagLibSourceFolder(IPath path) {
return path.segmentCount() > 2 && path.lastSegment().equals("taglib") && path.segment(1).equals(".link_to_grails_plugins");
}
/**
* return all the taglibs that are defined by grails itself.
* This does not include the most basic, built in ones
* such as 'if' and 'while'
*/
public List<TagLibClass> getStandardTagLibClasses() {
List<TagLibClass> taglibs = new ArrayList<TagLibClass>();
try {
IPackageFragment[] frags = javaProject.getPackageFragments();
for (IPackageFragment frag : frags) {
if (frag.getElementName().equals("org.codehaus.groovy.grails.plugins.web.taglib") && frag.exists()) {
// STS-3841: Actually not only one fragment can be found
IClassFile[] classes = frag.getClassFiles();
for (IClassFile classFile : classes) {
if (classFile.getType().getElementName().endsWith("TagLib")) {
taglibs.add(new BinaryTagLibClass((ClassFile) classFile));
}
}
}
}
} catch (JavaModelException e) {
GrailsCoreActivator.log("Exception raised when looking for Grails tag libaries. " +
"They typically reside in the package 'org.codehaus.groovy.grails.plugins.web.taglib'.",
e);
}
return taglibs;
}
/**
* For testing
*/
private static Map<String, GrailsElementKind> cuHandleToElementKind = new HashMap<String, GrailsElementKind>();
/**
* This class is not public API. It is used for testing to populate grails projects with default
* element kinds
* @param compilationUnitHandle
* @param kind
*/
public static void addExtraGrailsElement(GroovyCompilationUnit unit, GrailsElementKind kind) {
cuHandleToElementKind.put(unit.getHandleIdentifier(), kind);
}
/**
* This class is not public api. Used for testing only
* @param compilationUnitHandle
*/
public static void removeExtraGrailsElement(GroovyCompilationUnit unit) {
cuHandleToElementKind.remove(unit.getHandleIdentifier());
}
public IJavaProject getJavaProject() {
return getGroovyProject().getProject();
}
/**
* This is a handle only method.
*
* @return IFolder referring to the 'views' folder in the Grails project.
*/
public IFolder getViewsFolder() {
return getJavaProject().getProject().getFolder(new Path("grails-app/views"));
}
public GrailsVersion getGrailsVersion() {
return GrailsVersion.getGrailsVersion(javaProject.getProject());
}
public GrailsVersion getEclipseGrailsVersion() {
return GrailsVersion.getEclipseGrailsVersion(javaProject.getProject());
}
public List<IFile> getGSPFiles() {
IFolder parent = getViewsFolder();
final ArrayList<IFile> gspFiles = new ArrayList<IFile>();
try {
parent.accept(new IResourceVisitor() {
public boolean visit(IResource resource) throws CoreException {
if ((resource.getType()&IResource.FILE)!=0) {
if (resource.getName().endsWith(".gsp")) {
gspFiles.add((IFile) resource);
}
}
return true;
}
});
} catch (CoreException e) {
GrailsCoreActivator.log(e);
}
return gspFiles;
}
}