/*******************************************************************************
* Copyright (c) 2004, 2017 Tasktop Technologies and others.
* 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:
* Tasktop Technologies - initial API and implementation
*******************************************************************************/
package org.eclipse.dltk.internal.mylyn.search;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IMember;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.IType;
import org.eclipse.dltk.core.search.IDLTKSearchConstants;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.core.search.SearchEngine;
import org.eclipse.dltk.internal.core.ScriptProject;
import org.eclipse.dltk.internal.mylyn.DLTKStructureBridge;
import org.eclipse.dltk.internal.mylyn.DLTKUiBridgePlugin;
import org.eclipse.dltk.internal.ui.search.DLTKSearchQuery;
import org.eclipse.dltk.internal.ui.search.DLTKSearchResult;
import org.eclipse.dltk.ui.search.ElementQuerySpecification;
import org.eclipse.dltk.ui.search.QuerySpecification;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IInteractionElement;
import org.eclipse.mylyn.internal.context.core.AbstractRelationProvider;
import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;
import org.eclipse.mylyn.internal.context.core.DegreeOfSeparation;
import org.eclipse.mylyn.internal.context.core.IActiveSearchListener;
import org.eclipse.mylyn.internal.context.core.IActiveSearchOperation;
import org.eclipse.mylyn.internal.context.core.IDegreeOfSeparation;
import org.eclipse.mylyn.internal.resources.ui.ResourcesUiBridgePlugin;
import org.eclipse.search.ui.ISearchResult;
import org.eclipse.search2.internal.ui.InternalSearchUI;
/**
* @author Mik Kersten
*/
public abstract class AbstractJavaRelationProvider extends AbstractRelationProvider {
public static final String ID_GENERIC = "org.eclipse.mylyn.java.relation"; //$NON-NLS-1$
public static final String NAME = "Java relationships"; //$NON-NLS-1$
private static final int DEFAULT_DEGREE = 2;
private static final List<Job> runningJobs = new ArrayList<>();
@Override
public String getGenericId() {
return ID_GENERIC;
}
protected AbstractJavaRelationProvider(String structureKind, String id) {
super(structureKind, id);
}
@Override
public List<IDegreeOfSeparation> getDegreesOfSeparation() {
List<IDegreeOfSeparation> separations = new ArrayList<>();
separations.add(new DegreeOfSeparation(DOS_0_LABEL, 0));
separations.add(new DegreeOfSeparation(DOS_1_LABEL, 1));
separations.add(new DegreeOfSeparation(DOS_2_LABEL, 2));
separations.add(new DegreeOfSeparation(DOS_3_LABEL, 3));
separations.add(new DegreeOfSeparation(DOS_4_LABEL, 4));
separations.add(new DegreeOfSeparation(DOS_5_LABEL, 5));
return separations;
}
@Override
protected void findRelated(final IInteractionElement node, int degreeOfSeparation) {
if (node == null) {
return;
}
if (node.getContentType() == null) {
StatusHandler.log(new Status(IStatus.WARNING, DLTKUiBridgePlugin.ID_PLUGIN, "Null content type for: " //$NON-NLS-1$
+ node));
return;
}
if (!node.getContentType().equals(DLTKStructureBridge.CONTENT_TYPE)) {
return;
}
IModelElement javaElement = DLTKCore.create(node.getHandleIdentifier());
if (!acceptElement(javaElement) || !javaElement.exists()/*
* ||
* javaElement
* instanceof
* IInitializer
*/) {
return;
}
IDLTKSearchScope scope = createJavaSearchScope(javaElement, degreeOfSeparation);
if (scope != null) {
runJob(node, degreeOfSeparation, getId());
}
}
private IDLTKSearchScope createJavaSearchScope(IModelElement element, int degreeOfSeparation) {
Set<IInteractionElement> landmarks = ContextCore.getContextManager().getActiveLandmarks();
List<IInteractionElement> interestingElements = ContextCore.getContextManager()
.getActiveContext()
.getInteresting();
Set<IModelElement> searchElements = new HashSet<>();
int includeMask = IDLTKSearchScope.SOURCES;
if (degreeOfSeparation == 1) {
for (IInteractionElement landmark : landmarks) {
AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(landmark.getContentType());
if (includeNodeInScope(landmark, bridge)) {
Object o = bridge.getObjectForHandle(landmark.getHandleIdentifier());
if (o instanceof IModelElement) {
IModelElement landmarkElement = (IModelElement) o;
if (landmarkElement.exists()) {
if (landmarkElement instanceof IMember && !landmark.getInterest().isPropagated()) {
searchElements.add(((IMember) landmarkElement).getSourceModule());
} else if (landmarkElement instanceof ISourceModule) {
searchElements.add(landmarkElement);
}
}
}
}
}
} else if (degreeOfSeparation == 2) {
for (IInteractionElement interesting : interestingElements) {
AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(interesting.getContentType());
if (includeNodeInScope(interesting, bridge)) {
Object object = bridge.getObjectForHandle(interesting.getHandleIdentifier());
if (object instanceof IModelElement) {
IModelElement interestingElement = (IModelElement) object;
if (interestingElement.exists()) {
if (interestingElement instanceof IMember && !interesting.getInterest().isPropagated()) {
searchElements.add(((IMember) interestingElement).getSourceModule());
} else if (interestingElement instanceof ISourceModule) {
searchElements.add(interestingElement);
}
}
}
}
}
} else if (degreeOfSeparation == 3 || degreeOfSeparation == 4) {
for (IInteractionElement interesting : interestingElements) {
AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(interesting.getContentType());
if (includeNodeInScope(interesting, bridge)) {
// TODO what to do when the element is not a java element,
// how determine if a javaProject?
IResource resource = ResourcesUiBridgePlugin.getDefault().getResourceForElement(interesting, true);
if (resource != null) {
IProject project = resource.getProject();
if (project != null && ScriptProject.hasScriptNature(project) && project.exists()) {
IScriptProject javaProject = DLTKCore.create(project);// ((IModelElement)o).getJavaProject();
if (javaProject != null && javaProject.exists()) {
searchElements.add(javaProject);
}
}
}
}
}
if (degreeOfSeparation == 4) {
includeMask = IDLTKSearchScope.SOURCES | IDLTKSearchScope.APPLICATION_LIBRARIES
| IDLTKSearchScope.SYSTEM_LIBRARIES;
}
} else if (degreeOfSeparation == 5) {
return SearchEngine.createWorkspaceScope(DLTKLanguageManager.getLanguageToolkit(element));
}
if (searchElements.size() == 0) {
return null;
} else {
IModelElement[] elements = new IModelElement[searchElements.size()];
int j = 0;
for (IModelElement searchElement : searchElements) {
elements[j] = searchElement;
j++;
}
return SearchEngine.createSearchScope(elements, includeMask,
DLTKLanguageManager.getLanguageToolkit(element));
}
}
/**
* Only include Java elements and files.
*/
private boolean includeNodeInScope(IInteractionElement interesting, AbstractContextStructureBridge bridge) {
if (interesting == null || bridge == null) {
return false;
} else {
if (interesting.getContentType() == null) {
// TODO: remove
StatusHandler.log(new Status(IStatus.WARNING, DLTKUiBridgePlugin.ID_PLUGIN, "Null content type for: " //$NON-NLS-1$
+ interesting.getHandleIdentifier()));
return false;
} else {
return interesting.getContentType().equals(DLTKStructureBridge.CONTENT_TYPE)
|| bridge.isDocument(interesting.getHandleIdentifier());
}
}
}
protected boolean acceptResultElement(IModelElement element) {
return true; // !(element instanceof IImportDeclaration);
}
protected boolean acceptElement(IModelElement javaElement) {
return javaElement != null && (javaElement instanceof IMember || javaElement instanceof IType);
}
private void runJob(final IInteractionElement node, final int degreeOfSeparation, final String kind) {
int limitTo = 0;
if (kind.equals(DLTKReferencesProvider.ID)) {
limitTo = IDLTKSearchConstants.REFERENCES;
// } else if (kind.equals(JavaImplementorsProvider.ID)) {
// limitTo = IDLTKSearchConstants.IMPLEMENTORS;
} else if (kind.equals(JUnitReferencesProvider.ID)) {
limitTo = IDLTKSearchConstants.REFERENCES;
} else if (kind.equals(DLTKReadAccessProvider.ID)) {
limitTo = IDLTKSearchConstants.REFERENCES;
} else if (kind.equals(DLTKWriteAccessProvider.ID)) {
limitTo = IDLTKSearchConstants.REFERENCES;
}
final JavaSearchOperation query = (JavaSearchOperation) getSearchOperation(node, limitTo, degreeOfSeparation);
if (query == null) {
return;
}
JavaSearchJob job = new JavaSearchJob(query.getLabel(), query);
query.addListener(new IActiveSearchListener() {
private boolean gathered = false;
@Override
public boolean resultsGathered() {
return gathered;
}
@Override
public void searchCompleted(List<?> l) {
if (l == null) {
return;
}
List<IModelElement> relatedHandles = new ArrayList<>();
Object[] elements = l.toArray();
for (Object element : elements) {
if (element instanceof IModelElement) {
relatedHandles.add((IModelElement) element);
}
}
for (IModelElement element : relatedHandles) {
if (!acceptResultElement(element)) {
continue;
}
incrementInterest(node, DLTKStructureBridge.CONTENT_TYPE, element.getHandleIdentifier(),
degreeOfSeparation);
}
gathered = true;
AbstractJavaRelationProvider.this.searchCompleted(node);
}
});
InternalSearchUI.getInstance();
runningJobs.add(job);
job.setPriority(Job.DECORATE - 10);
job.schedule();
}
@Override
public IActiveSearchOperation getSearchOperation(IInteractionElement node, int limitTo, int degreeOfSeparation) {
IModelElement javaElement = DLTKCore.create(node.getHandleIdentifier());
if (javaElement == null || !javaElement.exists()) {
return null;
}
IDLTKSearchScope scope = createJavaSearchScope(javaElement, degreeOfSeparation);
if (scope == null) {
return null;
}
QuerySpecification specs = new ElementQuerySpecification(javaElement, limitTo, scope,
Messages.AbstractJavaRelationProvider_Mylyn_degree_of_separation + degreeOfSeparation);
return new JavaSearchOperation(specs);
}
protected static class JavaSearchJob extends Job {
private final JavaSearchOperation op;
public JavaSearchJob(String name, JavaSearchOperation op) {
super(name);
this.op = op;
}
/**
* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
protected IStatus run(IProgressMonitor monitor) {
return op.run(monitor);
}
}
protected static class JavaSearchOperation extends DLTKSearchQuery implements IActiveSearchOperation {
private ISearchResult result = null;
@Override
public ISearchResult getSearchResult() {
if (result == null) {
result = new DLTKSearchResult(this);
}
new DLTKActiveSearchResultUpdater((DLTKSearchResult) result);
return result;
}
@Override
public IStatus run(IProgressMonitor monitor) {
try {
IStatus runStatus = super.run(monitor);
ISearchResult result = getSearchResult();
if (result instanceof DLTKSearchResult) {
// TODO make better
Object[] objs = ((DLTKSearchResult) result).getElements();
if (objs == null) {
notifySearchCompleted(null);
} else {
List<Object> l = new ArrayList<>();
for (Object obj : objs) {
l.add(obj);
}
notifySearchCompleted(l);
}
}
return runStatus;
} catch (Throwable t) {
StatusHandler.log(new Status(IStatus.ERROR, DLTKUiBridgePlugin.ID_PLUGIN, "Java search failed", t)); //$NON-NLS-1$
}
IStatus status = new Status(IStatus.WARNING, ContextCorePlugin.ID_PLUGIN, IStatus.OK,
Messages.AbstractJavaRelationProvider_could_not_run_Java_search, null);
notifySearchCompleted(null);
return status;
}
/**
* Constructor
*
* @param data
*/
public JavaSearchOperation(QuerySpecification data) {
super(data);
}
/** List of listeners wanting to know about the searches */
private final List<IActiveSearchListener> listeners = new ArrayList<>();
/**
* Add a listener for when the bugzilla search is completed
*
* @param l
* The listener to add
*/
@Override
public void addListener(IActiveSearchListener l) {
// add the listener to the list
listeners.add(l);
}
/**
* Remove a listener for when the bugzilla search is completed
*
* @param l
* The listener to remove
*/
@Override
public void removeListener(IActiveSearchListener l) {
// remove the listener from the list
listeners.remove(l);
}
/**
* Notify all of the listeners that the bugzilla search is completed
*
* @param doiList
* A list of BugzillaSearchHitDoiInfo
* @param member
* The IMember that the search was performed on
*/
public void notifySearchCompleted(List<Object> l) {
// go through all of the listeners and call
// searchCompleted(colelctor,
// member)
for (IActiveSearchListener listener : listeners) {
listener.searchCompleted(l);
}
}
}
@Override
public void stopAllRunningJobs() {
for (Job j : runningJobs) {
j.cancel();
}
runningJobs.clear();
}
@Override
protected int getDefaultDegreeOfSeparation() {
return DEFAULT_DEGREE;
}
}