/*******************************************************************************
* Copyright (c) 2004, 2008 IBM Corporation 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:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.wst.xml.core.internal.search;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.wst.common.core.search.SearchMatch;
import org.eclipse.wst.common.core.search.SearchParticipant;
import org.eclipse.wst.common.core.search.SearchRequestor;
import org.eclipse.wst.common.core.search.document.ComponentDeclarationEntry;
import org.eclipse.wst.common.core.search.document.Entry;
import org.eclipse.wst.common.core.search.document.FileReferenceEntry;
import org.eclipse.wst.common.core.search.document.SearchDocument;
import org.eclipse.wst.common.core.search.document.SearchDocumentSet;
import org.eclipse.wst.common.core.search.pattern.ComponentSearchPattern;
import org.eclipse.wst.common.core.search.pattern.FileReferencePattern;
import org.eclipse.wst.common.core.search.pattern.SearchPattern;
import org.eclipse.wst.common.core.search.scope.ContentTypeSearchScope;
import org.eclipse.wst.common.core.search.scope.SearchScope;
import org.eclipse.wst.common.uriresolver.internal.provisional.URIResolver;
import org.eclipse.wst.common.uriresolver.internal.provisional.URIResolverPlugin;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xml.core.internal.search.impl.IXMLSearchConstants;
import org.eclipse.wst.xml.core.internal.search.impl.XMLSearchDocument;
import org.eclipse.wst.xml.core.internal.search.matching.PatternMatcher;
import org.eclipse.wst.xml.core.internal.search.matching.XMLSearchPatternMatcher;
import org.eclipse.wst.xml.core.internal.search.quickscan.XMLQuickScan;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
*
*/
public abstract class XMLSearchParticipant extends SearchParticipant {
protected static final boolean debugPerf = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.xml.core.internal.search/perf")); //$NON-NLS-1$ //$NON-NLS-2$
public XMLSearchParticipant() {
super();
}
/*
public boolean initialize(SearchPattern pattern, String[] contentTypes){
super.initialize(pattern, contentTypes);
this.supportedContentTypes = contentTypes;
if(pattern instanceof XMLComponentSearchPattern){
return true;
}
return false;
}*/
public SearchDocument createSearchDocument(String documentPath) {
return new XMLSearchDocument(documentPath, this);
}
public String getDescription() {
return "XML search participant"; //$NON-NLS-1$
}
private void locateMatches(SearchPattern pattern, SearchDocument document,
SearchRequestor requestor, Map searchOptions, IProgressMonitor monitor) {
// TODO... utilize search options (that should get passed down via the SearchEngine)
// to specify if accurate source coordinates are req'd if not, simply use the SAX results
//
if (pattern.getMatchRule() == SearchPattern.R_PATTERN_MATCH)
{
IFile file = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(document.getPath()));
// TODO.. don't assume the category is COMPONENT_DECL... handle any arbitarty category
Entry[] entries = document.getEntries(IXMLSearchConstants.COMPONENT_DECL, null, 0);
for (int i = 0; i < entries.length; i++)
{
// TODO.. don't assume this is just a component declaration entry
ComponentDeclarationEntry entry = (ComponentDeclarationEntry)entries[i];
SearchMatch searchMatch = new SearchMatch(null, 0, 0, file);
searchMatch.map.put("name", entry.getName()); //$NON-NLS-1$
searchMatch.map.put("metaName", entry.getMetaName()); //$NON-NLS-1$
try
{
requestor.acceptSearchMatch(searchMatch);
}
catch (Exception e)
{
}
}
}
else
{ if (document.getModel() instanceof IDOMModel) {
IDOMModel domModel = (IDOMModel) document.getModel();
IDOMElement contextNode = (IDOMElement) domModel.getDocument()
.getDocumentElement();
DOMVisitor visitor = new DOMVisitor(document.getPath(), pattern,
requestor);
visitor.visit(contextNode);
}
}
}
private PatternMatcher getAdapter(Object adaptableObject, Class adapterType) {
if (PatternMatcher.class.equals(adapterType) &&
(adaptableObject instanceof XMLSearchPattern ||
adaptableObject instanceof XMLComponentSearchPattern) ) {
return new XMLSearchPatternMatcher(this);
}
return null;
}
private class DOMVisitor {
String path;
SearchPattern pattern;
SearchRequestor requestor;
PatternMatcher matcher;
protected DOMVisitor(String path, SearchPattern pattern,
SearchRequestor requestor) {
super();
this.path = path;
this.pattern = pattern;
matcher = (PatternMatcher)pattern.getAdapter(PatternMatcher.class);
if(matcher == null){
matcher = getAdapter(pattern, PatternMatcher.class);
}
this.requestor = requestor;
}
private void visit(Node node) {
if (node.getNodeType() == Node.ELEMENT_NODE) {
match((Element)node);
NodeList nodeList = node.getChildNodes();
for (int i = 0; i < nodeList.getLength(); i++) {
Node aNode = nodeList.item(i);
visit(aNode);
}
}
}
private void match(Element node) {
IFile file = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(
new Path(path));
if(matcher != null){
matcher.locateMatches(pattern, file, node, requestor);
}
}
}
public SearchScope selectDocumentLocations(SearchPattern pattern, SearchScope scope, Map searchOptions, IProgressMonitor monitor) {
/*
* gate #1: reduce the scope to the files with the content type that
* could be searched using this participant
*/
String[] contentTypes = getSupportedContentTypes();
if(contentTypes != null && contentTypes.length > 0){
scope = new ContentTypeSearchScope(scope, contentTypes);
}
return super.selectDocumentLocations(pattern, scope, searchOptions, monitor);
}
public abstract ComponentSearchContributor getSearchContributor();
public void beginSearching(SearchPattern pattern, Map searchOptions) {
super.beginSearching(pattern, searchOptions);
if(pattern instanceof XMLComponentDeclarationPattern){
XMLComponentDeclarationPattern componentPattern = (XMLComponentDeclarationPattern)pattern;
XMLSearchPattern childPattern = getSearchContributor().getDeclarationPattern(componentPattern.getMetaName());
if(childPattern != null){
childPattern.setSearchName(componentPattern.getName().getLocalName());
childPattern.setSearchNamespace(componentPattern.getName().getNamespace());
componentPattern.addChildren(this, new XMLSearchPattern[]{childPattern});
}
}
else if(pattern instanceof XMLComponentReferencePattern){
XMLComponentReferencePattern componentPattern = (XMLComponentReferencePattern)pattern;
XMLSearchPattern[] childPatterns = getSearchContributor().getReferencesPatterns(componentPattern.getMetaName());
for (int i = 0; i < childPatterns.length; i++) {
XMLSearchPattern childPattern = childPatterns[i];
childPattern.setSearchName(componentPattern.getName().getLocalName());
childPattern.setSearchNamespace(componentPattern.getName().getNamespace());
}
componentPattern.addChildren(this, childPatterns);
}
}
/**
* The intend of this method is to limit the search to the files that have content
* which can be searched for the given pattern. It is called from
* {@link #selectDocumentLocations(SearchPattern, SearchScope, IProgressMonitor)}
*
* @param pattern the search pattern that is searched for
* @return content type's unique identifiers that could be searched for the given pattern.
*/
public abstract String[] getSupportedContentTypes();
public void populateSearchDocument(SearchDocument document, SearchPattern pattern)
{
PatternMatcher matcher = (PatternMatcher)pattern.getAdapter(PatternMatcher.class);
if(matcher == null){
matcher = getAdapter(pattern, PatternMatcher.class);
}
XMLQuickScan.populateSearchDocument(document, matcher, pattern);
}
public void locateMatches(SearchDocumentSet documentSet, SearchPattern pattern, SearchScope scope, SearchRequestor requestor, Map searchOptions, IProgressMonitor monitor) throws CoreException
{
long time = System.currentTimeMillis();
// TODO: use the file reference entries in the documents to reduce the scope to the referenced files only
// SearchDocument[] documents = documentSet.getSearchDocuments(id);
// check to see if the search pattern is qualified by a file location
// if this is the case then we can use file scoping rules to prune the matches
IFile targetFile = null;
if (pattern instanceof ComponentSearchPattern)
{
ComponentSearchPattern componentSearchPattern = (ComponentSearchPattern)pattern;
targetFile = componentSearchPattern.getFile();
}
// here we should have in scope only referenced files
IFile[] files = scope.enclosingFiles();
for (int i = 0; i < files.length; i++)
{
IFile file = files[i];
String path = file.getLocation().toString();
SearchDocument document = documentSet.getSearchDocument(path, id);
if (document != null)
{
Entry[] entries = document.getEntries(getSearchEntryCategory(pattern), null, 0);
if ((entries != null && entries.length > 0) || (searchOptions != null && searchOptions.get("searchDirtyContent") != null))
{
//for (int j = 0; j < entries.length; j++)
//{
// Entry entry = entries[j];
//System.out.println("entry " + entry.getCategory() + " " + entry.getKey() + " " + entry.getClass().getName());
//}
boolean isInScope = true;
if (targetFile != null)
{
try
{
isInScope = isLinked(documentSet, "file:///" + path, "file:///" + targetFile.getLocation().toString()); //$NON-NLS-1$ //$NON-NLS-2$
//if (path.endsWith("CancelSelection.wsdl") && path.indexOf("clone1") != -1)
//{
// fileReferenceTable.debug(qualifiedPath, 0, 5);
//}
}
catch (Exception e)
{
e.printStackTrace();
}
}
if (isInScope)
{
this.locateMatches(pattern, document, requestor, searchOptions, monitor);
}
}
}
}
if (debugPerf)
{
System.out
.println("" //$NON-NLS-1$
+ getDescription()
+ ": " + (System.currentTimeMillis() - time) + "ms for locateMatches"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
private boolean isLinked(SearchDocumentSet set, String source, String target)
{
return isLinked(set, source, target, new HashMap());
}
private boolean isLinked(SearchDocumentSet set, String source, String target, HashMap visited)
{
if (source.equals(target))
return true;
String fileProtocol = "file:///"; //$NON-NLS-1$
// Fix for bug 204174 - Begin
if(target.charAt(fileProtocol.length()) == '/') //$NON-NLS-1$
{
target = fileProtocol + target.substring(fileProtocol.length() + 1);
}
// Fix for bug 204174 - End
if (source.startsWith(fileProtocol))
{
SearchDocument document = set._tempGetSearchDocumetn(source.substring(fileProtocol.length()));
if (document != null)
{
URIResolver uriResolver = URIResolverPlugin.createResolver();
Entry[] entries = document.getEntries(IXMLSearchConstants.REF, null, 0);
String[] resolveEntry = new String[entries.length];
for (int j = 0; j < entries.length; j++)
{
Entry entry = entries[j];
if (entry instanceof FileReferenceEntry)
{
FileReferenceEntry fileReferenceEntry = (FileReferenceEntry)entry;
// TODO.. record an utilize the public id from the fileReferenceEntry
//
if (fileReferenceEntry.getRelativeFilePath() != null)
{
String resolvedURI = uriResolver.resolve(source, null, fileReferenceEntry.getRelativeFilePath());
resolveEntry[j] = resolvedURI;
if (resolvedURI.equals(target))
{
return true;
}
}
}
}
// now see if there's an indirect link from the source to the target
// we keep track of the nodes we've already visited to avoid cycles
if (visited.get(source) == null)
{
visited.put(source, Boolean.TRUE);
for (int j = 0; j < entries.length; j++)
{
String resolvedURI = resolveEntry[j];
if (resolvedURI != null && isLinked(set, resolveEntry[j], target, visited))
return true;
}
}
}
}
return false;
}
public static String getSearchEntryCategory(SearchPattern pattern){
if(pattern instanceof XMLComponentDeclarationPattern){
return IXMLSearchConstants.COMPONENT_DECL;
}
else if(pattern instanceof XMLComponentReferencePattern){
return IXMLSearchConstants.COMPONENT_REF;
}
else if(pattern instanceof FileReferencePattern){
return IXMLSearchConstants.COMPONENT_REF;
}
return null;
}
}