/*******************************************************************************
* Copyright (c) 2004, 2010 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.jst.jsp.ui.internal.java.refactoring;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.search.SearchDocument;
import org.eclipse.jdt.core.search.SearchMatch;
import org.eclipse.jdt.core.search.SearchRequestor;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jst.jsp.core.internal.java.search.JSPSearchSupport;
import org.eclipse.jst.jsp.core.internal.java.search.JavaSearchDocumentDelegate;
import org.eclipse.jst.jsp.ui.internal.JSPUIMessages;
import org.eclipse.jst.jsp.ui.internal.Logger;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.TextChange;
import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant;
import org.eclipse.osgi.util.NLS;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.text.edits.TextEditGroup;
/**
* <p>After a search is run with this {@link SearchRequestor} {@link #getChanges(RefactoringParticipant)}
* can be called to get any new {@link Change}s that need to be created as a result of the search. If
* {@link Change}s are already existing for the documents found then new {@link Change}s will not be
* created for them, but the needed {@link TextEdit}s will be added to the existing {@link Change}s.</p>
*/
public class BasicRefactorSearchRequestor extends SearchRequestor {
/** The type being renamed (the old type)*/
IJavaElement fElement = null;
/** The new name of the type being renamed*/
private String fNewName = ""; //$NON-NLS-1$
/** maps a JSPSearchDocument path -> MultiTextEdit for the java file*/
private HashMap fSearchDocPath2JavaEditMap = null;
public BasicRefactorSearchRequestor(IJavaElement element, String newName) {
this.fNewName = newName;
this.fElement = element;
this.fSearchDocPath2JavaEditMap = new HashMap();
}
public IJavaElement getElement() {
return this.fElement;
}
/**
* @return the new name for the Type
*/
public String getNewName() {
return this.fNewName;
}
/**
* @see org.eclipse.jdt.core.search.SearchRequestor#acceptSearchMatch(org.eclipse.jdt.core.search.SearchMatch)
*/
public void acceptSearchMatch(SearchMatch javaMatch) throws CoreException {
String matchDocumentPath = javaMatch.getResource().getFullPath().toString();
SearchDocument searchDoc = JSPSearchSupport.getInstance().getSearchDocument(matchDocumentPath);
if (searchDoc != null && searchDoc instanceof JavaSearchDocumentDelegate) {
String renameText = getRenameText((JavaSearchDocumentDelegate)searchDoc, javaMatch);
//if rename text is null then don't create an edit for it
if(renameText != null) {
// add it for the correct document
addJavaEdit(searchDoc.getPath(), new ReplaceEdit(javaMatch.getOffset(), javaMatch.getLength(), renameText));
}
}
}
/**
* @param searchDoc
* @return the rename text or <code>null</code> if no edit should be created for the given match.
* Such a case would be a match where nothing needs to be edited.
*/
protected String getRenameText(JavaSearchDocumentDelegate searchDoc, SearchMatch javaMatch) {
return getNewName();
}
/**
* Adds to the multi edit for a give java document.
* @param javaDocument
* @param javaEdit
*/
private void addJavaEdit(String searchDocPath, ReplaceEdit javaEdit) {
Object o = this.fSearchDocPath2JavaEditMap.get(searchDocPath);
if(o != null) {
MultiTextEdit multi = (MultiTextEdit)o;
multi.addChild(javaEdit);
}
else {
// use a multi edit so doc position offsets get updated automatically
// when adding multiple child edits
MultiTextEdit multi = new MultiTextEdit();
multi.addChild(javaEdit);
this.fSearchDocPath2JavaEditMap.put(searchDocPath, multi);
}
}
/**
* <p>This function is not safe because it does not check for existing {@link Change}s that
* new {@link Change}s created by this method may conflict with. These conflicts can
* cause indeterminate results when applied to documents. Long story short, don't
* use this method any more.</p>
*
* @return all JSP changes for the search matches for the given Type, they may conflict
* with already existing {@link Change}s
*
* @see #getChanges(RefactoringParticipant)
*
* @deprecated
*/
public Change[] getChanges() {
JSPSearchSupport support = JSPSearchSupport.getInstance();
List changes = new ArrayList();
Iterator keys = fSearchDocPath2JavaEditMap.keySet().iterator();
String searchDocPath = null;
SearchDocument delegate = null;
while(keys.hasNext()) {
// create on the fly
searchDocPath = (String)keys.next();
MultiTextEdit javaEdit = (MultiTextEdit)fSearchDocPath2JavaEditMap.get(searchDocPath);
delegate = support.getSearchDocument(searchDocPath);
if(delegate != null && delegate instanceof JavaSearchDocumentDelegate) {
JavaSearchDocumentDelegate javaDelegate = (JavaSearchDocumentDelegate)delegate;
changes.add(createChange(javaDelegate, javaDelegate.getJspTranslation().getJspEdit(javaEdit)));
}
}
return (Change[])changes.toArray(new Change[changes.size()]);
}
/**
* Gets new {@link Change}s created as a result of this {@link SearchRequestor}.
* Any existing {@link TextChange}s that had new edits added to them will not be
* returned.
*
* @param participant {@link RefactoringParticipant} to determine if there are already existing
* {@link TextChange}s for the documents that this {@link SearchRequestor} found.
* If existing
* {@link TextChange}s are found then they will be used for any new edits, else new {@link TextChange}s
* will be created.
*
* @return Any new {@link TextChange}s created by this {@link SearchRequestor}. If edits were
* added to existing {@link TextChange}s then those existing {@link TextChange}s will not be
* returned in this array.
*/
public Change[] getChanges(RefactoringParticipant participant) {
JSPSearchSupport support = JSPSearchSupport.getInstance();
List changes = new ArrayList();
Iterator keys = fSearchDocPath2JavaEditMap.keySet().iterator();
String searchDocPath = null;
SearchDocument delegate = null;
while(keys.hasNext()) {
// create on the fly
searchDocPath = (String)keys.next();
MultiTextEdit javaEdit = (MultiTextEdit)fSearchDocPath2JavaEditMap.get(searchDocPath);
delegate = support.getSearchDocument(searchDocPath);
if(delegate != null && delegate instanceof JavaSearchDocumentDelegate) {
JavaSearchDocumentDelegate javaDelegate = (JavaSearchDocumentDelegate)delegate;
Change change = createChange(javaDelegate, javaDelegate.getJspTranslation().getJspEdit(javaEdit), participant);
changes.add(change);
}
}
return (Change[])changes.toArray(new Change[changes.size()]);
}
/**
* <p>This method is not safe because it does not take into consideration already existing
* {@link Change}s and thus conflicts could occur that when applied create indeterminate
* results in the target documents</p>
*
* @see #createChange(JavaSearchDocumentDelegate, TextEdit, RefactoringParticipant)
*
* @deprecated
*/
private Change createChange(JavaSearchDocumentDelegate searchDoc, TextEdit edit) {
IDocument doc = searchDoc.getJspTranslation().getJspDocument();
String file = searchDoc.getFile().getName();
String description = getDescription();
try {
// document lines are 0 based
String lineNumber = Integer.toString(doc.getLineOfOffset(edit.getOffset()) + 1);
description += " " + NLS.bind(JSPUIMessages.BasicRefactorSearchRequestor_1, new String[]{file, lineNumber}); //$NON-NLS-1$
}
catch (BadLocationException e) {
Logger.logException(e);
}
return new JSPRenameChange(searchDoc.getFile(), doc, edit, description);
}
/**
* </p>If a {@link TextChange} does not already exist for the given {@link JavaSearchDocumentDelegate}
* then a new one will be created with the given {@link TextEdit}. Otherwise the given {@link TextEdit}
* will be added to a new group and added to the existing change and <code>null</code> will be returned.</p>
*
* @param searchDoc the {@link JavaSearchDocumentDelegate} that the <code>edit</code> will be applied to
* @param edit the {@link TextEdit} that needs to be added to a new {@link TextChange} or appended to an
* existing one
* @param participant the {@link RefactoringParticipant} that knows about the existing {@link TextChange}s
* @return a new {@link Change} if there was not one already existing for the document in question,
* else <code>null</code>
*/
private Change createChange(JavaSearchDocumentDelegate searchDoc, TextEdit edit, RefactoringParticipant participant) {
IDocument doc = searchDoc.getJspTranslation().getJspDocument();
String description = getDescription();
TextChange existingChange = participant.getTextChange(searchDoc.getFile());
TextChange change = null;
if(existingChange != null) {
try {
existingChange.addEdit(edit);
}catch (MalformedTreeException e) {
Logger.logException("MalformedTreeException while adding edit " + //$NON-NLS-1$
edit + " to existing change " + change, e); //$NON-NLS-1$
}
TextEditGroup group = new TextEditGroup(description, edit);
existingChange.addTextEditGroup(group);
} else {
change = new JSPRenameChange(searchDoc.getFile(), doc, edit, searchDoc.getFile().getName());
TextEditGroup group = new TextEditGroup(description, edit);
change.addTextEditGroup(group);
}
return change;
}
// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=3205
// only relevant for IType refactorings
protected boolean isFullyQualified(String matchText) {
if(getElement() instanceof IType) {
String pkg = ((IType)getElement()).getPackageFragment().getElementName();
return matchText.startsWith(pkg);
}
return false;
}
/**
* Subclasses should override to better describe the change.
* @return
*/
protected String getDescription() {
return ""; //$NON-NLS-1$
}
}