| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/org/documents/epl-v10.php |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ide.eclipse.adt.internal.refactorings.core; |
| |
| import static com.android.SdkConstants.ANDROID_MANIFEST_XML; |
| import static com.android.SdkConstants.ANDROID_PREFIX; |
| import static com.android.SdkConstants.ANDROID_THEME_PREFIX; |
| import static com.android.SdkConstants.ATTR_NAME; |
| import static com.android.SdkConstants.ATTR_TYPE; |
| import static com.android.SdkConstants.TAG_ITEM; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.resources.ResourceUrl; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.resources.ResourceType; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.internal.corext.refactoring.rename.RenameTypeProcessor; |
| import org.eclipse.jdt.internal.ui.refactoring.reorg.RenameTypeWizard; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.ITextSelection; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.ltk.core.refactoring.participants.RenameRefactoring; |
| import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.ITextEditor; |
| import org.eclipse.ui.texteditor.ITextEditorExtension; |
| import org.eclipse.ui.texteditor.ITextEditorExtension2; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| import java.util.List; |
| |
| /** |
| * Text action for XML files to invoke renaming |
| * <p> |
| * TODO: Handle other types of renaming: invoking class renaming when editing |
| * class names in layout files and manifest files, renaming attribute names when |
| * editing a styleable attribute, etc. |
| */ |
| @SuppressWarnings("restriction") // Java rename refactoring |
| public final class RenameResourceXmlTextAction extends Action { |
| private final ITextEditor mEditor; |
| |
| /** |
| * Creates a new {@linkplain RenameResourceXmlTextAction} |
| * |
| * @param editor the associated editor |
| */ |
| public RenameResourceXmlTextAction(@NonNull ITextEditor editor) { |
| super("Rename"); |
| mEditor = editor; |
| } |
| |
| @Override |
| public void run() { |
| if (!validateEditorInputState()) { |
| return; |
| } |
| IFile file = getFile(); |
| if (file == null) { |
| return; |
| } |
| IProject project = file.getProject(); |
| if (project == null) { |
| return; |
| } |
| IDocument document = getDocument(); |
| if (document == null) { |
| return; |
| } |
| ITextSelection selection = getSelection(); |
| if (selection == null) { |
| return; |
| } |
| |
| ResourceUrl resource = findResource(document, selection.getOffset()); |
| |
| if (resource == null) { |
| resource = findItemDefinition(document, selection.getOffset()); |
| } |
| |
| if (resource != null) { |
| ResourceType type = resource.type; |
| String name = resource.name; |
| Shell shell = mEditor.getSite().getShell(); |
| boolean canClear = false; |
| |
| RenameResourceWizard.renameResource(shell, project, type, name, null, canClear); |
| return; |
| } |
| |
| String className = findClassName(document, file, selection.getOffset()); |
| if (className != null) { |
| assert className.equals(className.trim()); |
| IType type = findType(className, project); |
| if (type != null) { |
| RenameTypeProcessor processor = new RenameTypeProcessor(type); |
| //processor.setNewElementName(className); |
| processor.setUpdateQualifiedNames(true); |
| processor.setUpdateSimilarDeclarations(false); |
| //processor.setMatchStrategy(?); |
| //processor.setFilePatterns(patterns); |
| processor.setUpdateReferences(true); |
| |
| RenameRefactoring refactoring = new RenameRefactoring(processor); |
| RenameTypeWizard wizard = new RenameTypeWizard(refactoring); |
| RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wizard); |
| try { |
| IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| op.run(window.getShell(), wizard.getDefaultPageTitle()); |
| } catch (InterruptedException e) { |
| } |
| } |
| |
| return; |
| } |
| |
| // Fallback: tell user the cursor isn't in the right place |
| MessageDialog.openInformation(mEditor.getSite().getShell(), |
| "Rename", |
| "Operation unavailable on the current selection.\n" |
| + "Select an Android resource name or class."); |
| } |
| |
| private boolean validateEditorInputState() { |
| if (mEditor instanceof ITextEditorExtension2) |
| return ((ITextEditorExtension2) mEditor).validateEditorInputState(); |
| else if (mEditor instanceof ITextEditorExtension) |
| return !((ITextEditorExtension) mEditor).isEditorInputReadOnly(); |
| else if (mEditor != null) |
| return mEditor.isEditable(); |
| else |
| return false; |
| } |
| |
| /** |
| * Searches for a resource URL around the caret, such as {@code @string/foo} |
| * |
| * @param document the document to search in |
| * @param offset the offset to search at |
| * @return a resource pair, or null if not found |
| */ |
| @Nullable |
| public static ResourceUrl findResource(@NonNull IDocument document, int offset) { |
| try { |
| int max = document.getLength(); |
| if (offset >= max) { |
| offset = max - 1; |
| } else if (offset < 0) { |
| offset = 0; |
| } else if (offset > 0) { |
| // If the caret is right after a resource name (meaning getChar(offset) points |
| // to the following character), back up |
| char c = document.getChar(offset); |
| if (!isValidResourceNameChar(c)) { |
| offset--; |
| } |
| } |
| |
| int start = offset; |
| boolean valid = true; |
| for (; start >= 0; start--) { |
| char c = document.getChar(start); |
| if (c == '@' || c == '?') { |
| break; |
| } else if (!isValidResourceNameChar(c)) { |
| valid = false; |
| break; |
| } |
| } |
| if (valid) { |
| // Search forwards for the end |
| int end = start + 1; |
| for (; end < max; end++) { |
| char c = document.getChar(end); |
| if (!isValidResourceNameChar(c)) { |
| break; |
| } |
| } |
| if (end > start + 1) { |
| String url = document.get(start, end - start); |
| |
| // Don't allow renaming framework resources -- @android:string/ok etc |
| if (url.startsWith(ANDROID_PREFIX) || url.startsWith(ANDROID_THEME_PREFIX)) { |
| return null; |
| } |
| |
| return ResourceUrl.parse(url); |
| } |
| } |
| } catch (BadLocationException e) { |
| AdtPlugin.log(e, null); |
| } |
| |
| return null; |
| } |
| |
| private static boolean isValidResourceNameChar(char c) { |
| return c == '@' || c == '?' || c == '/' || c == '+' || Character.isJavaIdentifierPart(c); |
| } |
| |
| /** |
| * Searches for an item definition around the caret, such as |
| * {@code <string name="foo">My String</string>} |
| */ |
| private ResourceUrl findItemDefinition(IDocument document, int offset) { |
| Node node = DomUtilities.getNode(document, offset); |
| if (node == null) { |
| return null; |
| } |
| if (node.getNodeType() == Node.TEXT_NODE) { |
| node = node.getParentNode(); |
| } |
| if (node == null || node.getNodeType() != Node.ELEMENT_NODE) { |
| return null; |
| } |
| |
| Element element = (Element) node; |
| String name = element.getAttribute(ATTR_NAME); |
| if (name == null || name.isEmpty()) { |
| return null; |
| } |
| String typeString = element.getTagName(); |
| if (TAG_ITEM.equals(typeString)) { |
| typeString = element.getAttribute(ATTR_TYPE); |
| if (typeString == null || typeString.isEmpty()) { |
| return null; |
| } |
| } |
| ResourceType type = ResourceType.getEnum(typeString); |
| if (type != null) { |
| return ResourceUrl.create(type, name, false, false); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Searches for a fully qualified class name around the caret, such as {@code foo.bar.MyClass} |
| * |
| * @param document the document to search in |
| * @param file the file, if known |
| * @param offset the offset to search at |
| * @return a resource pair, or null if not found |
| */ |
| @Nullable |
| public static String findClassName( |
| @NonNull IDocument document, |
| @Nullable IFile file, |
| int offset) { |
| try { |
| int max = document.getLength(); |
| if (offset >= max) { |
| offset = max - 1; |
| } else if (offset < 0) { |
| offset = 0; |
| } else if (offset > 0) { |
| // If the caret is right after a resource name (meaning getChar(offset) points |
| // to the following character), back up |
| char c = document.getChar(offset); |
| if (Character.isJavaIdentifierPart(c)) { |
| offset--; |
| } |
| } |
| |
| int start = offset; |
| for (; start >= 0; start--) { |
| char c = document.getChar(start); |
| if (c == '"' || c == '<' || c == '/') { |
| start++; |
| break; |
| } else if (c != '.' && !Character.isJavaIdentifierPart(c)) { |
| return null; |
| } |
| } |
| // Search forwards for the end |
| int end = start + 1; |
| for (; end < max; end++) { |
| char c = document.getChar(end); |
| if (c != '.' && !Character.isJavaIdentifierPart(c)) { |
| if (c != '"' && c != '>' && !Character.isWhitespace(c)) { |
| return null; |
| } |
| break; |
| } |
| } |
| if (end > start + 1) { |
| String fqcn = document.get(start, end - start); |
| int dot = fqcn.indexOf('.'); |
| if (dot == -1) { // Only support fully qualified names |
| return null; |
| } |
| if (dot == 0) { // Special case for manifests: prepend package |
| if (file != null && file.getName().equals(ANDROID_MANIFEST_XML)) { |
| ManifestInfo info = ManifestInfo.get(file.getProject()); |
| return info.getPackage() + fqcn; |
| } |
| return null; |
| } |
| |
| return fqcn; |
| } |
| } catch (BadLocationException e) { |
| AdtPlugin.log(e, null); |
| } |
| |
| return null; |
| } |
| |
| @Nullable |
| private IType findType(@NonNull String className, @NonNull IProject project) { |
| IType type = null; |
| try { |
| IJavaProject javaProject = BaseProjectHelper.getJavaProject(project); |
| type = javaProject.findType(className); |
| if (type == null || !type.exists()) { |
| return null; |
| } |
| if (!type.isBinary()) { |
| return type; |
| } |
| // See if this class is coming through a library project jar file and |
| // if so locate the real class |
| ProjectState projectState = Sdk.getProjectState(project); |
| if (projectState != null) { |
| List<IProject> libraries = projectState.getFullLibraryProjects(); |
| for (IProject library : libraries) { |
| javaProject = BaseProjectHelper.getJavaProject(library); |
| type = javaProject.findType(className); |
| if (type != null && type.exists() && !type.isBinary()) { |
| return type; |
| } |
| } |
| } |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| |
| return null; |
| } |
| |
| private ITextSelection getSelection() { |
| ISelectionProvider selectionProvider = mEditor.getSelectionProvider(); |
| if (selectionProvider == null) { |
| return null; |
| } |
| ISelection selection = selectionProvider.getSelection(); |
| if (!(selection instanceof ITextSelection)) { |
| return null; |
| } |
| return (ITextSelection) selection; |
| } |
| |
| private IDocument getDocument() { |
| IDocumentProvider documentProvider = mEditor.getDocumentProvider(); |
| if (documentProvider == null) { |
| return null; |
| } |
| IDocument document = documentProvider.getDocument(mEditor.getEditorInput()); |
| if (document == null) { |
| return null; |
| } |
| return document; |
| } |
| |
| @Nullable |
| private IFile getFile() { |
| IEditorInput input = mEditor.getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| IFileEditorInput fileInput = (IFileEditorInput) input; |
| return fileInput.getFile(); |
| } |
| |
| return null; |
| } |
| } |
