bundles/org.eclipse.jst.jsp.ui/src/org/eclipse/jst/jsp/ui/internal/java/refactoring/BasicRefactorSearchRequestor.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * 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$
 	}
 }
	/*******************************************************************************
	* 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$
	}
	}