Java tutorial
/* * Copyright (C) 2009 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.extractstring; import static com.android.SdkConstants.QUOT_ENTITY; import static com.android.SdkConstants.STRING_PREFIX; import com.android.SdkConstants; import com.android.ide.common.res2.ValueXmlHelper; import com.android.ide.common.xml.ManifestData; import com.android.ide.eclipse.adt.AdtConstants; import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor; import com.android.ide.eclipse.adt.internal.editors.descriptors.ReferenceAttributeDescriptor; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiAttributeNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; import com.android.ide.eclipse.adt.internal.project.AndroidManifestHelper; import com.android.resources.ResourceFolderType; import com.android.resources.ResourceType; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IFolder; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.ResourceAttributes; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.core.runtime.Path; import org.eclipse.core.runtime.SubMonitor; import org.eclipse.jdt.core.IBuffer; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IPackageFragment; import org.eclipse.jdt.core.IPackageFragmentRoot; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.core.ToolFactory; import org.eclipse.jdt.core.compiler.IScanner; import org.eclipse.jdt.core.compiler.ITerminalSymbols; import org.eclipse.jdt.core.compiler.InvalidInputException; import org.eclipse.jdt.core.dom.AST; import org.eclipse.jdt.core.dom.ASTNode; import org.eclipse.jdt.core.dom.ASTParser; import org.eclipse.jdt.core.dom.CompilationUnit; import org.eclipse.jdt.core.dom.rewrite.ASTRewrite; import org.eclipse.jdt.core.dom.rewrite.ImportRewrite; import org.eclipse.jface.text.ITextSelection; import org.eclipse.ltk.core.refactoring.Change; import org.eclipse.ltk.core.refactoring.ChangeDescriptor; import org.eclipse.ltk.core.refactoring.CompositeChange; import org.eclipse.ltk.core.refactoring.Refactoring; import org.eclipse.ltk.core.refactoring.RefactoringChangeDescriptor; import org.eclipse.ltk.core.refactoring.RefactoringStatus; import org.eclipse.ltk.core.refactoring.TextEditChangeGroup; import org.eclipse.ltk.core.refactoring.TextFileChange; import org.eclipse.text.edits.InsertEdit; import org.eclipse.text.edits.MultiTextEdit; import org.eclipse.text.edits.ReplaceEdit; import org.eclipse.text.edits.TextEdit; import org.eclipse.text.edits.TextEditGroup; import org.eclipse.ui.IEditorPart; import org.eclipse.wst.sse.core.StructuredModelManager; import org.eclipse.wst.sse.core.internal.provisional.IModelManager; import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument; import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion; import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion; import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList; import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext; import org.w3c.dom.Node; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Queue; /** * This refactoring extracts a string from a file and replaces it by an Android resource ID * such as R.string.foo. * <p/> * There are a number of scenarios, which are not all supported yet. The workflow works as * such: * <ul> * <li> User selects a string in a Java and invokes the {@link ExtractStringAction}. * <li> The action finds the {@link ICompilationUnit} being edited as well as the current * {@link ITextSelection}. The action creates a new instance of this refactoring as * well as an {@link ExtractStringWizard} and runs the operation. * <li> Step 1 of the refactoring is to check the preliminary conditions. Right now we check * that the java source is not read-only and is in sync. We also try to find a string under * the selection. If this fails, the refactoring is aborted. * <li> On success, the wizard is shown, which lets the user input the new ID to use. * <li> The wizard sets the user input values into this refactoring instance, e.g. the new string * ID, the XML file to update, etc. The wizard does use the utility method * {@link XmlStringFileHelper#valueOfStringId(IProject, String, String)} to check whether * the new ID is already defined in the target XML file. * <li> Once Preview or Finish is selected in the wizard, the * {@link #checkFinalConditions(IProgressMonitor)} is called to double-check the user input * and compute the actual changes. * <li> When all changes are computed, {@link #createChange(IProgressMonitor)} is invoked. * </ul> * * The list of changes are: * <ul> * <li> If the target XML does not exist, create it with the new string ID. * <li> If the target XML exists, find the <resources> node and add the new string ID right after. * If the node is <resources/>, it needs to be opened. * <li> Create an AST rewriter to edit the source Java file and replace all occurrences by the * new computed R.string.foo. Also need to rewrite imports to import R as needed. * If there's already a conflicting R included, we need to insert the FQCN instead. * <li> TODO: Have a pref in the wizard: [x] Change other XML Files * <li> TODO: Have a pref in the wizard: [x] Change other Java Files * </ul> */ @SuppressWarnings("restriction") public class ExtractStringRefactoring extends Refactoring { public enum Mode { /** * the Extract String refactoring is called on an <em>existing</em> source file. * Its purpose is then to get the selected string of the source and propose to * change it by an XML id. The XML id may be a new one or an existing one. */ EDIT_SOURCE, /** * The Extract String refactoring is called without any source file. * Its purpose is then to create a new XML string ID or select/modify an existing one. */ SELECT_ID, /** * The Extract String refactoring is called without any source file. * Its purpose is then to create a new XML string ID. The ID must not already exist. */ SELECT_NEW_ID } /** The {@link Mode} of operation of the refactoring. */ private final Mode mMode; /** Non-null when editing an Android Resource XML file: identifies the attribute name * of the value being edited. When null, the source is an Android Java file. */ private String mXmlAttributeName; /** The file model being manipulated. * Value is null when not on {@link Mode#EDIT_SOURCE} mode. */ private final IFile mFile; /** The editor. Non-null when invoked from {@link ExtractStringAction}. Null otherwise. */ private final IEditorPart mEditor; /** The project that contains {@link #mFile} and that contains the target XML file to modify. */ private final IProject mProject; /** The start of the selection in {@link #mFile}. * Value is -1 when not on {@link Mode#EDIT_SOURCE} mode. */ private final int mSelectionStart; /** The end of the selection in {@link #mFile}. * Value is -1 when not on {@link Mode#EDIT_SOURCE} mode. */ private final int mSelectionEnd; /** The compilation unit, only defined if {@link #mFile} points to a usable Java source file. */ private ICompilationUnit mUnit; /** The actual string selected, after UTF characters have been escaped, good for display. * Value is null when not on {@link Mode#EDIT_SOURCE} mode. */ private String mTokenString; /** The XML string ID selected by the user in the wizard. */ private String mXmlStringId; /** The XML string value. Might be different than the initial selected string. */ private String mXmlStringValue; /** The path of the XML file that will define {@link #mXmlStringId}, selected by the user * in the wizard. This is relative to the project, e.g. "/res/values/string.xml" */ private String mTargetXmlFileWsPath; /** True if we should find & replace in all Java files. */ private boolean mReplaceAllJava; /** True if we should find & replace in all XML files of the same name in other res configs * (other than the main {@link #mTargetXmlFileWsPath}.) */ private boolean mReplaceAllXml; /** The list of changes computed by {@link #checkFinalConditions(IProgressMonitor)} and * used by {@link #createChange(IProgressMonitor)}. */ private ArrayList<Change> mChanges; private XmlStringFileHelper mXmlHelper = new XmlStringFileHelper(); private static final String KEY_MODE = "mode"; //$NON-NLS-1$ private static final String KEY_FILE = "file"; //$NON-NLS-1$ private static final String KEY_PROJECT = "proj"; //$NON-NLS-1$ private static final String KEY_SEL_START = "sel-start"; //$NON-NLS-1$ private static final String KEY_SEL_END = "sel-end"; //$NON-NLS-1$ private static final String KEY_TOK_ESC = "tok-esc"; //$NON-NLS-1$ private static final String KEY_XML_ATTR_NAME = "xml-attr-name"; //$NON-NLS-1$ private static final String KEY_RPLC_ALL_JAVA = "rplc-all-java"; //$NON-NLS-1$ private static final String KEY_RPLC_ALL_XML = "rplc-all-xml"; //$NON-NLS-1$ /** * This constructor is solely used by {@link ExtractStringDescriptor}, * to replay a previous refactoring. * <p/> * To create a refactoring from code, please use one of the two other constructors. * * @param arguments A map previously created using {@link #createArgumentMap()}. * @throws NullPointerException */ public ExtractStringRefactoring(Map<String, String> arguments) throws NullPointerException { mReplaceAllJava = Boolean.parseBoolean(arguments.get(KEY_RPLC_ALL_JAVA)); mReplaceAllXml = Boolean.parseBoolean(arguments.get(KEY_RPLC_ALL_XML)); mMode = Mode.valueOf(arguments.get(KEY_MODE)); IPath path = Path.fromPortableString(arguments.get(KEY_PROJECT)); mProject = (IProject) ResourcesPlugin.getWorkspace().getRoot().findMember(path); if (mMode == Mode.EDIT_SOURCE) { path = Path.fromPortableString(arguments.get(KEY_FILE)); mFile = (IFile) ResourcesPlugin.getWorkspace().getRoot().findMember(path); mSelectionStart = Integer.parseInt(arguments.get(KEY_SEL_START)); mSelectionEnd = Integer.parseInt(arguments.get(KEY_SEL_END)); mTokenString = arguments.get(KEY_TOK_ESC); mXmlAttributeName = arguments.get(KEY_XML_ATTR_NAME); } else { mFile = null; mSelectionStart = mSelectionEnd = -1; mTokenString = null; mXmlAttributeName = null; } mEditor = null; } private Map<String, String> createArgumentMap() { HashMap<String, String> args = new HashMap<String, String>(); args.put(KEY_RPLC_ALL_JAVA, Boolean.toString(mReplaceAllJava)); args.put(KEY_RPLC_ALL_XML, Boolean.toString(mReplaceAllXml)); args.put(KEY_MODE, mMode.name()); args.put(KEY_PROJECT, mProject.getFullPath().toPortableString()); if (mMode == Mode.EDIT_SOURCE) { args.put(KEY_FILE, mFile.getFullPath().toPortableString()); args.put(KEY_SEL_START, Integer.toString(mSelectionStart)); args.put(KEY_SEL_END, Integer.toString(mSelectionEnd)); args.put(KEY_TOK_ESC, mTokenString); args.put(KEY_XML_ATTR_NAME, mXmlAttributeName); } return args; } /** * Constructor to use when the Extract String refactoring is called on an * *existing* source file. Its purpose is then to get the selected string of * the source and propose to change it by an XML id. The XML id may be a new one * or an existing one. * * @param file The source file to process. Cannot be null. File must exist in workspace. * @param editor The editor. * @param selection The selection in the source file. Cannot be null or empty. */ public ExtractStringRefactoring(IFile file, IEditorPart editor, ITextSelection selection) { mMode = Mode.EDIT_SOURCE; mFile = file; mEditor = editor; mProject = file.getProject(); mSelectionStart = selection.getOffset(); mSelectionEnd = mSelectionStart + Math.max(0, selection.getLength() - 1); } /** * Constructor to use when the Extract String refactoring is called without * any source file. Its purpose is then to create a new XML string ID. * <p/> * For example this is currently invoked by the ResourceChooser when * the user wants to create a new string rather than select an existing one. * * @param project The project where the target XML file to modify is located. Cannot be null. * @param enforceNew If true the XML ID must be a new one. * If false, an existing ID can be used. */ public ExtractStringRefactoring(IProject project, boolean enforceNew) { mMode = enforceNew ? Mode.SELECT_NEW_ID : Mode.SELECT_ID; mFile = null; mEditor = null; mProject = project; mSelectionStart = mSelectionEnd = -1; } /** * Sets the replacement string ID. Used by the wizard to set the user input. */ public void setNewStringId(String newStringId) { mXmlStringId = newStringId; } /** * Sets the replacement string ID. Used by the wizard to set the user input. */ public void setNewStringValue(String newStringValue) { mXmlStringValue = newStringValue; } /** * Sets the target file. This is a project path, e.g. "/res/values/strings.xml". * Used by the wizard to set the user input. */ public void setTargetFile(String targetXmlFileWsPath) { mTargetXmlFileWsPath = targetXmlFileWsPath; } public void setReplaceAllJava(boolean replaceAllJava) { mReplaceAllJava = replaceAllJava; } public void setReplaceAllXml(boolean replaceAllXml) { mReplaceAllXml = replaceAllXml; } /** * @see org.eclipse.ltk.core.refactoring.Refactoring#getName() */ @Override public String getName() { if (mMode == Mode.SELECT_ID) { return "Create or Use Android String"; } else if (mMode == Mode.SELECT_NEW_ID) { return "Create New Android String"; } return "Extract Android String"; } public Mode getMode() { return mMode; } /** * Gets the actual string selected, after UTF characters have been escaped, * good for display. Value can be null. */ public String getTokenString() { return mTokenString; } /** Returns the XML string ID selected by the user in the wizard. */ public String getXmlStringId() { return mXmlStringId; } /** * Step 1 of 3 of the refactoring: * Checks that the current selection meets the initial condition before the ExtractString * wizard is shown. The check is supposed to be lightweight and quick. Note that at that * point the wizard has not been created yet. * <p/> * Here we scan the source buffer to find the token matching the selection. * The check is successful is a Java string literal is selected, the source is in sync * and is not read-only. * <p/> * This is also used to extract the string to be modified, so that we can display it in * the refactoring wizard. * * @see org.eclipse.ltk.core.refactoring.Refactoring#checkInitialConditions(org.eclipse.core.runtime.IProgressMonitor) * * @throws CoreException */ @Override public RefactoringStatus checkInitialConditions(IProgressMonitor monitor) throws CoreException, OperationCanceledException { mUnit = null; mTokenString = null; RefactoringStatus status = new RefactoringStatus(); try { monitor.beginTask("Checking preconditions...", 6); if (mMode != Mode.EDIT_SOURCE) { monitor.worked(6); return status; } if (!checkSourceFile(mFile, status, monitor)) { return status; } // Try to get a compilation unit from this file. If it fails, mUnit is null. try { mUnit = JavaCore.createCompilationUnitFrom(mFile); // Make sure the unit is not read-only, e.g. it's not a class file or inside a Jar if (mUnit.isReadOnly()) { status.addFatalError("The file is read-only, please make it writeable first."); return status; } // This is a Java file. Check if it contains the selection we want. if (!findSelectionInJavaUnit(mUnit, status, monitor)) { return status; } } catch (Exception e) { // That was not a Java file. Ignore. } if (mUnit != null) { monitor.worked(1); return status; } // Check this a Layout XML file and get the selection and its context. if (mFile != null && SdkConstants.EXT_XML.equals(mFile.getFileExtension())) { // Currently we only support Android resource XML files, so they must have a path // similar to // project/res/<type>[-<configuration>]/*.xml // project/AndroidManifest.xml // There is no support for sub folders, so the segment count must be 4 or 2. // We don't need to check the type folder name because a/ we only accept // an AndroidXmlEditor source and b/ aapt generates a compilation error for // unknown folders. IPath path = mFile.getFullPath(); if ((path.segmentCount() == 4 && path.segment(1).equalsIgnoreCase(SdkConstants.FD_RESOURCES)) || (path.segmentCount() == 2 && path.segment(1).equalsIgnoreCase(SdkConstants.FN_ANDROID_MANIFEST_XML))) { if (!findSelectionInXmlFile(mFile, status, monitor)) { return status; } } } if (!status.isOK()) { status.addFatalError("Selection must be inside a Java source or an Android Layout XML file."); } } finally { monitor.done(); } return status; } /** * Try to find the selected Java element in the compilation unit. * * If selection matches a string literal, capture it, otherwise add a fatal error * to the status. * * On success, advance the monitor by 3. * Returns status.isOK(). */ private boolean findSelectionInJavaUnit(ICompilationUnit unit, RefactoringStatus status, IProgressMonitor monitor) { try { IBuffer buffer = unit.getBuffer(); IScanner scanner = ToolFactory.createScanner(false, //tokenizeComments false, //tokenizeWhiteSpace false, //assertMode false //recordLineSeparator ); scanner.setSource(buffer.getCharacters()); monitor.worked(1); for (int token = scanner.getNextToken(); token != ITerminalSymbols.TokenNameEOF; token = scanner .getNextToken()) { if (scanner.getCurrentTokenStartPosition() <= mSelectionStart && scanner.getCurrentTokenEndPosition() >= mSelectionEnd) { // found the token, but only keep if the right type if (token == ITerminalSymbols.TokenNameStringLiteral) { mTokenString = new String(scanner.getCurrentTokenSource()); } break; } else if (scanner.getCurrentTokenStartPosition() > mSelectionEnd) { // scanner is past the selection, abort. break; } } } catch (JavaModelException e1) { // Error in unit.getBuffer. Ignore. } catch (InvalidInputException e2) { // Error in scanner.getNextToken. Ignore. } finally { monitor.worked(1); } if (mTokenString != null) { // As a literal string, the token should have surrounding quotes. Remove them. // Note: unquoteAttrValue technically removes either " or ' paired quotes, whereas // the Java token should only have " quotes. Since we know the type to be a string // literal, there should be no confusion here. mTokenString = unquoteAttrValue(mTokenString); // We need a non-empty string literal if (mTokenString.length() == 0) { mTokenString = null; } } if (mTokenString == null) { status.addFatalError("Please select a Java string literal."); } monitor.worked(1); return status.isOK(); } /** * Try to find the selected XML element. This implementation replies on the refactoring * originating from an Android Layout Editor. We rely on some internal properties of the * Structured XML editor to retrieve file content to avoid parsing it again. We also rely * on our specific Android XML model to get element & attribute descriptor properties. * * If selection matches a string literal, capture it, otherwise add a fatal error * to the status. * * On success, advance the monitor by 1. * Returns status.isOK(). */ private boolean findSelectionInXmlFile(IFile file, RefactoringStatus status, IProgressMonitor monitor) { try { if (!(mEditor instanceof AndroidXmlEditor)) { status.addFatalError("Only the Android XML Editor is currently supported."); return status.isOK(); } AndroidXmlEditor editor = (AndroidXmlEditor) mEditor; IStructuredModel smodel = null; Node node = null; String currAttrName = null; try { // See the portability note in AndroidXmlEditor#getModelForRead() javadoc. smodel = editor.getModelForRead(); if (smodel != null) { // The structured model gives the us the actual XML Node element where the // offset is. By using this Node, we can find the exact UiElementNode of our // model and thus we'll be able to get the properties of the attribute -- to // check if it accepts a string reference. This does not however tell us if // the selection is actually in an attribute value, nor which attribute is // being edited. for (int offset = mSelectionStart; offset >= 0 && node == null; --offset) { node = (Node) smodel.getIndexedRegion(offset); } if (node == null) { status.addFatalError("The selection does not match any element in the XML document."); return status.isOK(); } if (node.getNodeType() != Node.ELEMENT_NODE) { status.addFatalError("The selection is not inside an actual XML element."); return status.isOK(); } IStructuredDocument sdoc = smodel.getStructuredDocument(); if (sdoc != null) { // Portability note: all the structured document implementation is // under wst.sse.core.internal.provisional so we can expect it to change in // a distant future if they start cleaning their codebase, however unlikely // that is. int selStart = mSelectionStart; IStructuredDocumentRegion region = sdoc.getRegionAtCharacterOffset(selStart); if (region != null && DOMRegionContext.XML_TAG_NAME.equals(region.getType())) { // Find if any sub-region representing an attribute contains the // selection. If it does, returns the name of the attribute in // currAttrName and returns the value in the field mTokenString. currAttrName = findSelectionInRegion(region, selStart); if (mTokenString == null) { status.addFatalError("The selection is not inside an actual XML attribute value."); } } } if (mTokenString != null && node != null && currAttrName != null) { // Validate that the attribute accepts a string reference. // This sets mTokenString to null by side-effect when it fails and // adds a fatal error to the status as needed. validateSelectedAttribute(editor, node, currAttrName, status); } else { // We shouldn't get here: we're missing one of the token string, the node // or the attribute name. All of them have been checked earlier so don't // set any specific error. mTokenString = null; } } } catch (Throwable t) { // Since we use some internal APIs, use a broad catch-all to report any // unexpected issue rather than crash the whole refactoring. status.addFatalError(String.format("XML parsing error: %1$s", t.getMessage())); } finally { if (smodel != null) { smodel.releaseFromRead(); } } } finally { monitor.worked(1); } return status.isOK(); } /** * The region gives us the textual representation of the XML element * where the selection starts, split using sub-regions. We now just * need to iterate through the sub-regions to find which one * contains the actual selection. We're interested in an attribute * value however when we find one we want to memorize the attribute * name that was defined just before. * * @return When the cursor is on a valid attribute name or value, returns the string of * attribute name. As a side-effect, returns the value of the attribute in {@link #mTokenString} */ private String findSelectionInRegion(IStructuredDocumentRegion region, int selStart) { String currAttrName = null; int startInRegion = selStart - region.getStartOffset(); int nb = region.getNumberOfRegions(); ITextRegionList list = region.getRegions(); String currAttrValue = null; for (int i = 0; i < nb; i++) { ITextRegion subRegion = list.get(i); String type = subRegion.getType(); if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(type)) { currAttrName = region.getText(subRegion); // I like to select the attribute definition and invoke // the extract string wizard. So if the selection is on // the attribute name part, find the value that is just // after and use it as if it were the selection. if (subRegion.getStart() <= startInRegion && startInRegion < subRegion.getTextEnd()) { // A well-formed attribute is composed of a name, // an equal sign and the value. There can't be any space // in between, which makes the parsing a lot easier. if (i <= nb - 3 && DOMRegionContext.XML_TAG_ATTRIBUTE_EQUALS.equals(list.get(i + 1).getType())) { subRegion = list.get(i + 2); type = subRegion.getType(); if (DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE.equals(type)) { currAttrValue = region.getText(subRegion); } } } } else if (subRegion.getStart() <= startInRegion && startInRegion < subRegion.getTextEnd() && DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE.equals(type)) { currAttrValue = region.getText(subRegion); } if (currAttrValue != null) { // We found the value. Only accept it if not empty // and if we found an attribute name before. String text = currAttrValue; // The attribute value contains XML quotes. Remove them. text = unquoteAttrValue(text); if (text.length() > 0 && currAttrName != null) { // Setting mTokenString to non-null marks the fact we // accept this attribute. mTokenString = text; } break; } } return currAttrName; } /** * Attribute values found as text for {@link DOMRegionContext#XML_TAG_ATTRIBUTE_VALUE} * contain XML quotes. This removes the quotes (either single or double quotes). * * @param attrValue The attribute value, as extracted by * {@link IStructuredDocumentRegion#getText(ITextRegion)}. * Must not be null. * @return The attribute value, without quotes. Whitespace is not trimmed, if any. * String may be empty, but not null. */ static String unquoteAttrValue(String attrValue) { int len = attrValue.length(); int len1 = len - 1; if (len >= 2 && attrValue.charAt(0) == '"' && attrValue.charAt(len1) == '"') { attrValue = attrValue.substring(1, len1); } else if (len >= 2 && attrValue.charAt(0) == '\'' && attrValue.charAt(len1) == '\'') { attrValue = attrValue.substring(1, len1); } return attrValue; } /** * Validates that the attribute accepts a string reference. * This sets mTokenString to null by side-effect when it fails and * adds a fatal error to the status as needed. */ private void validateSelectedAttribute(AndroidXmlEditor editor, Node node, String attrName, RefactoringStatus status) { UiElementNode rootUiNode = editor.getUiRootNode(); UiElementNode currentUiNode = rootUiNode == null ? null : rootUiNode.findXmlNode(node); ReferenceAttributeDescriptor attrDesc = null; if (currentUiNode != null) { // remove any namespace prefix from the attribute name String name = attrName; int pos = name.indexOf(':'); if (pos > 0 && pos < name.length() - 1) { name = name.substring(pos + 1); } for (UiAttributeNode attrNode : currentUiNode.getAllUiAttributes()) { if (attrNode.getDescriptor().getXmlLocalName().equals(name)) { AttributeDescriptor desc = attrNode.getDescriptor(); if (desc instanceof ReferenceAttributeDescriptor) { attrDesc = (ReferenceAttributeDescriptor) desc; } break; } } } // The attribute descriptor is a resource reference. It must either accept // of any resource type or specifically accept string types. if (attrDesc != null && (attrDesc.getResourceType() == null || attrDesc.getResourceType() == ResourceType.STRING)) { // We have one more check to do: is the current string value already // an Android XML string reference? If so, we can't edit it. if (mTokenString != null && mTokenString.startsWith("@")) { //$NON-NLS-1$ int pos1 = 0; if (mTokenString.length() > 1 && mTokenString.charAt(1) == '+') { pos1++; } int pos2 = mTokenString.indexOf('/'); if (pos2 > pos1) { String kind = mTokenString.substring(pos1 + 1, pos2); if (ResourceType.STRING.getName().equals(kind)) { mTokenString = null; status.addFatalError(String.format("The attribute %1$s already contains a %2$s reference.", attrName, kind)); } } } if (mTokenString != null) { // We're done with all our checks. mTokenString contains the // current attribute value. We don't memorize the region nor the // attribute, however we memorize the textual attribute name so // that we can offer replacement for all its occurrences. mXmlAttributeName = attrName; } } else { mTokenString = null; status.addFatalError(String.format("The attribute %1$s does not accept a string reference.", attrName)); } } /** * Tests from org.eclipse.jdt.internal.corext.refactoringChecks#validateEdit() * Might not be useful. * * On success, advance the monitor by 2. * * @return False if caller should abort, true if caller should continue. */ private boolean checkSourceFile(IFile file, RefactoringStatus status, IProgressMonitor monitor) { // check whether the source file is in sync if (!file.isSynchronized(IResource.DEPTH_ZERO)) { status.addFatalError("The file is not synchronized. Please save it first."); return false; } monitor.worked(1); // make sure we can write to it. ResourceAttributes resAttr = file.getResourceAttributes(); if (resAttr == null || resAttr.isReadOnly()) { status.addFatalError("The file is read-only, please make it writeable first."); return false; } monitor.worked(1); return true; } /** * Step 2 of 3 of the refactoring: * Check the conditions once the user filled values in the refactoring wizard, * then prepare the changes to be applied. * <p/> * In this case, most of the sanity checks are done by the wizard so essentially this * should only be called if the wizard positively validated the user input. * * Here we do check that the target resource XML file either does not exists or * is not read-only. * * @see org.eclipse.ltk.core.refactoring.Refactoring#checkFinalConditions(IProgressMonitor) * * @throws CoreException */ @Override public RefactoringStatus checkFinalConditions(IProgressMonitor monitor) throws CoreException, OperationCanceledException { RefactoringStatus status = new RefactoringStatus(); try { monitor.beginTask("Checking post-conditions...", 5); if (mXmlStringId == null || mXmlStringId.length() <= 0) { // this is not supposed to happen status.addFatalError("Missing replacement string ID"); } else if (mTargetXmlFileWsPath == null || mTargetXmlFileWsPath.length() <= 0) { // this is not supposed to happen status.addFatalError("Missing target xml file path"); } monitor.worked(1); // Either that resource must not exist or it must be a writable file. IResource targetXml = getTargetXmlResource(mTargetXmlFileWsPath); if (targetXml != null) { if (targetXml.getType() != IResource.FILE) { status.addFatalError(String.format("XML file '%1$s' is not a file.", mTargetXmlFileWsPath)); } else { ResourceAttributes attr = targetXml.getResourceAttributes(); if (attr != null && attr.isReadOnly()) { status.addFatalError(String.format("XML file '%1$s' is read-only.", mTargetXmlFileWsPath)); } } } monitor.worked(1); if (status.hasError()) { return status; } mChanges = new ArrayList<Change>(); // Prepare the change to create/edit the String ID in the res/values XML file. if (!mXmlStringValue.equals(mXmlHelper.valueOfStringId(mProject, mTargetXmlFileWsPath, mXmlStringId))) { // We actually change it only if the ID doesn't exist yet or has a different value Change change = createXmlChanges((IFile) targetXml, mXmlStringId, mXmlStringValue, status, SubMonitor.convert(monitor, 1)); if (change != null) { mChanges.add(change); } } if (status.hasError()) { return status; } if (mMode == Mode.EDIT_SOURCE) { List<Change> changes = null; if (mXmlAttributeName != null) { // Prepare the change to the Android resource XML file changes = computeXmlSourceChanges(mFile, mXmlStringId, mTokenString, mXmlAttributeName, true, // allConfigurations status, monitor); } else if (mUnit != null) { // Prepare the change to the Java compilation unit changes = computeJavaChanges(mUnit, mXmlStringId, mTokenString, status, SubMonitor.convert(monitor, 1)); } if (changes != null) { mChanges.addAll(changes); } } if (mReplaceAllJava) { String currentIdentifier = mUnit != null ? mUnit.getHandleIdentifier() : ""; //$NON-NLS-1$ SubMonitor submon = SubMonitor.convert(monitor, 1); for (ICompilationUnit unit : findAllJavaUnits()) { // Only process Java compilation units that exist, are not derived // and are not read-only. if (unit == null || !unit.exists()) { continue; } IResource resource = unit.getResource(); if (resource == null || resource.isDerived()) { continue; } // Ensure that we don't process the current compilation unit (processed // as mUnit above) twice if (currentIdentifier.equals(unit.getHandleIdentifier())) { continue; } ResourceAttributes attrs = resource.getResourceAttributes(); if (attrs != null && attrs.isReadOnly()) { continue; } List<Change> changes = computeJavaChanges(unit, mXmlStringId, mTokenString, status, SubMonitor.convert(submon, 1)); if (changes != null) { mChanges.addAll(changes); } } } if (mReplaceAllXml) { SubMonitor submon = SubMonitor.convert(monitor, 1); for (IFile xmlFile : findAllResXmlFiles()) { if (xmlFile != null) { List<Change> changes = computeXmlSourceChanges(xmlFile, mXmlStringId, mTokenString, mXmlAttributeName, false, // allConfigurations status, SubMonitor.convert(submon, 1)); if (changes != null) { mChanges.addAll(changes); } } } } monitor.worked(1); } finally { monitor.done(); } return status; } // --- XML changes --- /** * Returns a foreach-compatible iterator over all XML files in the project's * /res folder, excluding the target XML file (the one where we'll write/edit * the string id). */ private Iterable<IFile> findAllResXmlFiles() { return new Iterable<IFile>() { @Override public Iterator<IFile> iterator() { return new Iterator<IFile>() { final Queue<IFile> mFiles = new LinkedList<IFile>(); final Queue<IResource> mFolders = new LinkedList<IResource>(); IPath mFilterPath1 = null; IPath mFilterPath2 = null; { // Filter out the XML file where we'll be writing the XML string id. IResource filterRes = mProject.findMember(mTargetXmlFileWsPath); if (filterRes != null) { mFilterPath1 = filterRes.getFullPath(); } // Filter out the XML source file, if any (e.g. typically a layout) if (mFile != null) { mFilterPath2 = mFile.getFullPath(); } // We want to process the manifest IResource man = mProject.findMember("AndroidManifest.xml"); // TODO find a constant if (man.exists() && man instanceof IFile && !man.equals(mFile)) { mFiles.add((IFile) man); } // Add all /res folders (technically we don't need to process /res/values // XML files that contain resources/string elements, but it's easier to // not filter them out.) IFolder f = mProject.getFolder(AdtConstants.WS_RESOURCES); if (f.exists()) { try { mFolders.addAll(Arrays.asList(f.members(IContainer.EXCLUDE_DERIVED))); } catch (CoreException e) { // pass } } } @Override public boolean hasNext() { if (!mFiles.isEmpty()) { return true; } while (!mFolders.isEmpty()) { IResource res = mFolders.poll(); if (res.exists() && res instanceof IFolder) { IFolder f = (IFolder) res; try { getFileList(f); if (!mFiles.isEmpty()) { return true; } } catch (CoreException e) { // pass } } } return false; } private void getFileList(IFolder folder) throws CoreException { for (IResource res : folder.members(IContainer.EXCLUDE_DERIVED)) { // Only accept file resources which are not derived and actually exist if (res.exists() && !res.isDerived() && res instanceof IFile) { IFile file = (IFile) res; // Must have an XML extension if (SdkConstants.EXT_XML.equals(file.getFileExtension())) { IPath p = file.getFullPath(); // And not be either paths we want to filter out if ((mFilterPath1 != null && mFilterPath1.equals(p)) || (mFilterPath2 != null && mFilterPath2.equals(p))) { continue; } mFiles.add(file); } } } } @Override public IFile next() { IFile file = mFiles.poll(); hasNext(); return file; } @Override public void remove() { throw new UnsupportedOperationException("This iterator does not support removal"); //$NON-NLS-1$ } }; } }; } /** * Internal helper that actually prepares the {@link Change} that adds the given * ID to the given XML File. * <p/> * This does not actually modify the file. * * @param targetXml The file resource to modify. * @param xmlStringId The new ID to insert. * @param tokenString The old string, which will be the value in the XML string. * @return A new {@link TextEdit} that describes how to change the file. */ private Change createXmlChanges(IFile targetXml, String xmlStringId, String tokenString, RefactoringStatus status, SubMonitor monitor) { TextFileChange xmlChange = new TextFileChange(getName(), targetXml); xmlChange.setTextType(SdkConstants.EXT_XML); String error = ""; //$NON-NLS-1$ TextEdit edit = null; TextEditGroup editGroup = null; try { if (!targetXml.exists()) { // Kludge: use targetXml==null as a signal this is a new file being created targetXml = null; } edit = createXmlReplaceEdit(targetXml, xmlStringId, tokenString, status, SubMonitor.convert(monitor, 1)); } catch (IOException e) { error = e.toString(); } catch (CoreException e) { // Failed to read file. Ignore. Will handle error below. error = e.toString(); } if (edit == null) { status.addFatalError(String.format("Failed to modify file %1$s%2$s", targetXml == null ? "" : targetXml.getFullPath(), //$NON-NLS-1$ error == null ? "" : ": " + error)); //$NON-NLS-1$ return null; } editGroup = new TextEditGroup( targetXml == null ? "Create <string> in new XML file" : "Insert <string> in XML file", edit); xmlChange.setEdit(edit); // The TextEditChangeGroup let the user toggle this change on and off later. xmlChange.addTextEditChangeGroup(new TextEditChangeGroup(xmlChange, editGroup)); monitor.worked(1); return xmlChange; } /** * Scan the XML file to find the best place where to insert the new string element. * <p/> * This handles a variety of cases, including replacing existing ids in place, * adding the top resources element if missing and the XML PI if not present. * It tries to preserve indentation when adding new elements at the end of an existing XML. * * @param file The XML file to modify, that must be present in the workspace. * Pass null to create a change for a new file that doesn't exist yet. * @param xmlStringId The new ID to insert. * @param tokenString The old string, which will be the value in the XML string. * @param status The in-out refactoring status. Used to log a more detailed error if the * XML has a top element that is not a resources element. * @param monitor A monitor to track progress. * @return A new {@link TextEdit} for either a replace or an insert operation, or null in case * of error. * @throws CoreException - if the file's contents or description can not be read. * @throws IOException - if the file's contents can not be read or its detected encoding does * not support its contents. */ private TextEdit createXmlReplaceEdit(IFile file, String xmlStringId, String tokenString, RefactoringStatus status, SubMonitor monitor) throws IOException, CoreException { IModelManager modelMan = StructuredModelManager.getModelManager(); final String NODE_RESOURCES = SdkConstants.TAG_RESOURCES; final String NODE_STRING = SdkConstants.TAG_STRING; final String ATTR_NAME = SdkConstants.ATTR_NAME; // Scan the source to find the best insertion point. // 1- The most common case we need to handle is the one of inserting at the end // of a valid XML document, respecting the whitespace last used. // // Ideally we have this structure: // <xml ...> // <resource> // ...ws1...<string>blah</string>...ws2... // </resource> // // where ws1 and ws2 are the whitespace respectively before and after the last element // just before the closing </resource>. // In this case we want to generate the new string just before ws2...</resource> with // the same whitespace as ws1. // // 2- Another expected case is there's already an existing string which "name" attribute // equals to xmlStringId and we just want to replace its value. // // Other cases we need to handle: // 3- There is no element at all -> create a full new <resource>+<string> content. // 4- There is <resource/>, that is the tag is not opened. This can be handled as the // previous case, generating full content but also replacing <resource/>. // 5- There is a top element that is not <resource>. That's a fatal error and we abort. IStructuredModel smodel = null; // Single and double quotes must be escaped in the <string>value</string> declaration tokenString = ValueXmlHelper.escapeResourceString(tokenString); try { IStructuredDocument sdoc = null; boolean checkTopElement = true; boolean replaceStringContent = false; boolean hasPiXml = false; int newResStart = 0; int newResLength = 0; String lineSep = "\n"; //$NON-NLS-1$ if (file != null) { smodel = modelMan.getExistingModelForRead(file); if (smodel != null) { sdoc = smodel.getStructuredDocument(); } else if (smodel == null) { // The model is not currently open. if (file.exists()) { sdoc = modelMan.createStructuredDocumentFor(file); } else { sdoc = modelMan.createNewStructuredDocumentFor(file); } } } if (sdoc == null && file != null) { // Get a document matching the actual saved file sdoc = modelMan.createStructuredDocumentFor(file); } if (sdoc != null) { String wsBefore = ""; //$NON-NLS-1$ String lastWs = null; lineSep = sdoc.getLineDelimiter(); if (lineSep == null || lineSep.length() == 0) { // That wasn't too useful, let's go back to a reasonable default lineSep = "\n"; //$NON-NLS-1$ } for (IStructuredDocumentRegion regions : sdoc.getStructuredDocumentRegions()) { String type = regions.getType(); if (DOMRegionContext.XML_CONTENT.equals(type)) { if (replaceStringContent) { // Generate a replacement for a <string> value matching the string ID. return new ReplaceEdit(regions.getStartOffset(), regions.getLength(), tokenString); } // Otherwise capture what should be whitespace content lastWs = regions.getFullText(); continue; } else if (DOMRegionContext.XML_PI_OPEN.equals(type) && !hasPiXml) { int nb = regions.getNumberOfRegions(); ITextRegionList list = regions.getRegions(); for (int i = 0; i < nb; i++) { ITextRegion region = list.get(i); type = region.getType(); if (DOMRegionContext.XML_TAG_NAME.equals(type)) { String name = regions.getText(region); if ("xml".equals(name)) { //$NON-NLS-1$ hasPiXml = true; break; } } } continue; } else if (!DOMRegionContext.XML_TAG_NAME.equals(type)) { // ignore things which are not a tag nor text content (such as comments) continue; } int nb = regions.getNumberOfRegions(); ITextRegionList list = regions.getRegions(); String name = null; String attrName = null; String attrValue = null; boolean isEmptyTag = false; boolean isCloseTag = false; for (int i = 0; i < nb; i++) { ITextRegion region = list.get(i); type = region.getType(); if (DOMRegionContext.XML_END_TAG_OPEN.equals(type)) { isCloseTag = true; } else if (DOMRegionContext.XML_EMPTY_TAG_CLOSE.equals(type)) { isEmptyTag = true; } else if (DOMRegionContext.XML_TAG_NAME.equals(type)) { name = regions.getText(region); } else if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(type) && NODE_STRING.equals(name)) { // Record the attribute names into a <string> element. attrName = regions.getText(region); } else if (DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE.equals(type) && ATTR_NAME.equals(attrName)) { // Record the value of a <string name=...> attribute attrValue = regions.getText(region); if (attrValue != null && unquoteAttrValue(attrValue).equals(xmlStringId)) { // We found a <string name=> matching the string ID to replace. // We'll generate a replacement when we process the string value // (that is the next XML_CONTENT region.) replaceStringContent = true; } } } if (checkTopElement) { // Check the top element has a resource name checkTopElement = false; if (!NODE_RESOURCES.equals(name)) { status.addFatalError( String.format("XML file lacks a <resource> tag: %1$s", mTargetXmlFileWsPath)); return null; } if (isEmptyTag) { // The top element is an empty "<resource/>" tag. We need to do // a full new resource+string replacement. newResStart = regions.getStartOffset(); newResLength = regions.getLength(); } } if (NODE_RESOURCES.equals(name)) { if (isCloseTag) { // We found the </resource> tag and we want // to insert just before this one. StringBuilder content = new StringBuilder(); content.append(wsBefore).append("<string name=\"") //$NON-NLS-1$ .append(xmlStringId).append("\">") //$NON-NLS-1$ .append(tokenString).append("</string>"); //$NON-NLS-1$ // Backup to insert before the whitespace preceding </resource> IStructuredDocumentRegion insertBeforeReg = regions; while (true) { IStructuredDocumentRegion previous = insertBeforeReg.getPrevious(); if (previous != null && DOMRegionContext.XML_CONTENT.equals(previous.getType()) && previous.getText().trim().length() == 0) { insertBeforeReg = previous; } else { break; } } if (insertBeforeReg == regions) { // If we have not found any whitespace before </resources>, // at least add a line separator. content.append(lineSep); } return new InsertEdit(insertBeforeReg.getStartOffset(), content.toString()); } } else { // For any other tag than <resource>, capture whitespace before and after. if (!isCloseTag) { wsBefore = lastWs; } } } } // We reach here either because there's no XML content at all or because // there's an empty <resource/>. // Provide a full new resource+string replacement. StringBuilder content = new StringBuilder(); if (!hasPiXml) { content.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>"); //$NON-NLS-1$ content.append(lineSep); } else if (newResLength == 0 && sdoc != null) { // If inserting at the end, check if the last region is some whitespace. // If there's no newline, insert one ourselves. IStructuredDocumentRegion lastReg = sdoc.getLastStructuredDocumentRegion(); if (lastReg != null && lastReg.getText().indexOf('\n') == -1) { content.append('\n'); } } // FIXME how to access formatting preferences to generate the proper indentation? content.append("<resources>").append(lineSep); //$NON-NLS-1$ content.append(" <string name=\"") //$NON-NLS-1$ .append(xmlStringId).append("\">") //$NON-NLS-1$ .append(tokenString).append("</string>") //$NON-NLS-1$ .append(lineSep); content.append("</resources>").append(lineSep); //$NON-NLS-1$ if (newResLength > 0) { // Replace existing piece return new ReplaceEdit(newResStart, newResLength, content.toString()); } else { // Insert at the end. int offset = sdoc == null ? 0 : sdoc.getLength(); return new InsertEdit(offset, content.toString()); } } catch (IOException e) { // This is expected to happen and is properly reported to the UI. throw e; } catch (CoreException e) { // This is expected to happen and is properly reported to the UI. throw e; } catch (Throwable t) { // Since we use some internal APIs, use a broad catch-all to report any // unexpected issue rather than crash the whole refactoring. status.addFatalError(String.format("XML replace error: %1$s", t.getMessage())); } finally { if (smodel != null) { smodel.releaseFromRead(); } } return null; } /** * Computes the changes to be made to the source Android XML file and * returns a list of {@link Change}. * <p/> * This function scans an XML file, looking for an attribute value equals to * <code>tokenString</code>. If non null, <code>xmlAttrName</code> limit the search * to only attributes that have that name. * If found, a change is made to replace each occurrence of <code>tokenString</code> * by a new "@string/..." using the new <code>xmlStringId</code>. * * @param sourceFile The file to process. * A status error will be generated if it does not exists. * Must not be null. * @param tokenString The string to find. Must not be null or empty. * @param xmlAttrName Optional attribute name to limit the search. Can be null. * @param allConfigurations True if this function should can all XML files with the same * name and the same resource type folder but with different configurations. * @param status Status used to report fatal errors. * @param monitor Used to log progress. */ private List<Change> computeXmlSourceChanges(IFile sourceFile, String xmlStringId, String tokenString, String xmlAttrName, boolean allConfigurations, RefactoringStatus status, IProgressMonitor monitor) { if (!sourceFile.exists()) { status.addFatalError( String.format("XML file '%1$s' does not exist.", sourceFile.getFullPath().toOSString())); return null; } // We shouldn't be trying to replace a null or empty string. assert tokenString != null && tokenString.length() > 0; if (tokenString == null || tokenString.length() == 0) { return null; } // Note: initially this method was only processing files using a pattern // /project/res/<type>-<configuration>/<filename.xml> // However the last version made that more generic to be able to process any XML // files. We should probably revisit and simplify this later. HashSet<IFile> files = new HashSet<IFile>(); files.add(sourceFile); if (allConfigurations && SdkConstants.EXT_XML.equals(sourceFile.getFileExtension())) { IPath path = sourceFile.getFullPath(); if (path.segmentCount() == 4 && path.segment(1).equals(SdkConstants.FD_RESOURCES)) { IProject project = sourceFile.getProject(); String filename = path.segment(3); String initialTypeName = path.segment(2); ResourceFolderType type = ResourceFolderType.getFolderType(initialTypeName); IContainer res = sourceFile.getParent().getParent(); if (type != null && res != null && res.getType() == IResource.FOLDER) { try { for (IResource r : res.members()) { if (r != null && r.getType() == IResource.FOLDER) { String name = r.getName(); // Skip the initial folder name, it's already in the list. if (!name.equals(initialTypeName)) { // Only accept the same folder type (e.g. layout-*) ResourceFolderType t = ResourceFolderType.getFolderType(name); if (type.equals(t)) { // recompute the path IPath p = res.getProjectRelativePath().append(name).append(filename); IResource f = project.findMember(p); if (f != null && f instanceof IFile) { files.add((IFile) f); } } } } } } catch (CoreException e) { // Ignore. } } } } SubMonitor subMonitor = SubMonitor.convert(monitor, Math.min(1, files.size())); ArrayList<Change> changes = new ArrayList<Change>(); // Portability note: getModelManager is part of wst.sse.core however the // interface returned is part of wst.sse.core.internal.provisional so we can // expect it to change in a distant future if they start cleaning their codebase, // however unlikely that is. IModelManager modelManager = StructuredModelManager.getModelManager(); for (IFile file : files) { IStructuredModel smodel = null; MultiTextEdit multiEdit = null; TextFileChange xmlChange = null; ArrayList<TextEditGroup> editGroups = null; try { IStructuredDocument sdoc = null; smodel = modelManager.getExistingModelForRead(file); if (smodel != null) { sdoc = smodel.getStructuredDocument(); } else if (smodel == null) { // The model is not currently open. if (file.exists()) { sdoc = modelManager.createStructuredDocumentFor(file); } else { sdoc = modelManager.createNewStructuredDocumentFor(file); } } if (sdoc == null) { status.addFatalError("XML structured document not found"); //$NON-NLS-1$ continue; } multiEdit = new MultiTextEdit(); editGroups = new ArrayList<TextEditGroup>(); xmlChange = new TextFileChange(getName(), file); xmlChange.setTextType("xml"); //$NON-NLS-1$ String quotedReplacement = quotedAttrValue(STRING_PREFIX + xmlStringId); // Prepare the change set for (IStructuredDocumentRegion regions : sdoc.getStructuredDocumentRegions()) { // Only look at XML "top regions" if (!DOMRegionContext.XML_TAG_NAME.equals(regions.getType())) { continue; } int nb = regions.getNumberOfRegions(); ITextRegionList list = regions.getRegions(); String lastAttrName = null; for (int i = 0; i < nb; i++) { ITextRegion subRegion = list.get(i); String type = subRegion.getType(); if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(type)) { // Memorize the last attribute name seen lastAttrName = regions.getText(subRegion); } else if (DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE.equals(type)) { // Check this is the attribute and the original string String text = regions.getText(subRegion); // Remove " or ' quoting present in the attribute value text = unquoteAttrValue(text); if (tokenString.equals(text) && (xmlAttrName == null || xmlAttrName.equals(lastAttrName))) { // Found an occurrence. Create a change for it. TextEdit edit = new ReplaceEdit(regions.getStartOffset() + subRegion.getStart(), subRegion.getTextLength(), quotedReplacement); TextEditGroup editGroup = new TextEditGroup("Replace attribute string by ID", edit); multiEdit.addChild(edit); editGroups.add(editGroup); } } } } } catch (Throwable t) { // Since we use some internal APIs, use a broad catch-all to report any // unexpected issue rather than crash the whole refactoring. status.addFatalError(String.format("XML refactoring error: %1$s", t.getMessage())); } finally { if (smodel != null) { smodel.releaseFromRead(); } if (multiEdit != null && xmlChange != null && editGroups != null && multiEdit.hasChildren()) { xmlChange.setEdit(multiEdit); for (TextEditGroup group : editGroups) { xmlChange.addTextEditChangeGroup(new TextEditChangeGroup(xmlChange, group)); } changes.add(xmlChange); } subMonitor.worked(1); } } // for files if (changes.size() > 0) { return changes; } return null; } /** * Returns a quoted attribute value suitable to be placed after an attributeName= * statement in an XML stream. * * According to http://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue * the attribute value can be either quoted using ' or " and the corresponding * entities ' or " must be used inside. */ private String quotedAttrValue(String attrValue) { if (attrValue.indexOf('"') == -1) { // no double-quotes inside, use double-quotes around. return '"' + attrValue + '"'; } if (attrValue.indexOf('\'') == -1) { // no single-quotes inside, use single-quotes around. return '\'' + attrValue + '\''; } // If we get here, there's a mix. Opt for double-quote around and replace // inner double-quotes. attrValue = attrValue.replace("\"", QUOT_ENTITY); //$NON-NLS-1$ return '"' + attrValue + '"'; } // --- Java changes --- /** * Returns a foreach compatible iterator over all ICompilationUnit in the project. */ private Iterable<ICompilationUnit> findAllJavaUnits() { final IJavaProject javaProject = JavaCore.create(mProject); return new Iterable<ICompilationUnit>() { @Override public Iterator<ICompilationUnit> iterator() { return new Iterator<ICompilationUnit>() { final Queue<ICompilationUnit> mUnits = new LinkedList<ICompilationUnit>(); final Queue<IPackageFragment> mFragments = new LinkedList<IPackageFragment>(); { try { IPackageFragment[] tmpFrags = javaProject.getPackageFragments(); if (tmpFrags != null && tmpFrags.length > 0) { mFragments.addAll(Arrays.asList(tmpFrags)); } } catch (JavaModelException e) { // pass } } @Override public boolean hasNext() { if (!mUnits.isEmpty()) { return true; } while (!mFragments.isEmpty()) { try { IPackageFragment fragment = mFragments.poll(); if (fragment.getKind() == IPackageFragmentRoot.K_SOURCE) { ICompilationUnit[] tmpUnits = fragment.getCompilationUnits(); if (tmpUnits != null && tmpUnits.length > 0) { mUnits.addAll(Arrays.asList(tmpUnits)); return true; } } } catch (JavaModelException e) { // pass } } return false; } @Override public ICompilationUnit next() { ICompilationUnit unit = mUnits.poll(); hasNext(); return unit; } @Override public void remove() { throw new UnsupportedOperationException("This iterator does not support removal"); //$NON-NLS-1$ } }; } }; } /** * Computes the changes to be made to Java file(s) and returns a list of {@link Change}. * <p/> * This function scans a Java compilation unit using {@link ReplaceStringsVisitor}, looking * for a string literal equals to <code>tokenString</code>. * If found, a change is made to replace each occurrence of <code>tokenString</code> by * a piece of Java code that somehow accesses R.string.<code>xmlStringId</code>. * * @param unit The compilated unit to process. Must not be null. * @param tokenString The string to find. Must not be null or empty. * @param status Status used to report fatal errors. * @param monitor Used to log progress. */ private List<Change> computeJavaChanges(ICompilationUnit unit, String xmlStringId, String tokenString, RefactoringStatus status, SubMonitor monitor) { // We shouldn't be trying to replace a null or empty string. assert tokenString != null && tokenString.length() > 0; if (tokenString == null || tokenString.length() == 0) { return null; } // Get the Android package name from the Android Manifest. We need it to create // the FQCN of the R class. String packageName = null; String error = null; IResource manifestFile = mProject.findMember(SdkConstants.FN_ANDROID_MANIFEST_XML); if (manifestFile == null || manifestFile.getType() != IResource.FILE) { error = "File not found"; } else { ManifestData manifestData = AndroidManifestHelper.parseForData((IFile) manifestFile); if (manifestData == null) { error = "Invalid content"; } else { packageName = manifestData.getPackage(); if (packageName == null) { error = "Missing package definition"; } } } if (error != null) { status.addFatalError(String.format("Failed to parse file %1$s: %2$s.", manifestFile == null ? "" : manifestFile.getFullPath(), //$NON-NLS-1$ error)); return null; } // Right now the changes array will contain one TextFileChange at most. ArrayList<Change> changes = new ArrayList<Change>(); // This is the unit that will be modified. TextFileChange change = new TextFileChange(getName(), (IFile) unit.getResource()); change.setTextType("java"); //$NON-NLS-1$ // Create an AST for this compilation unit ASTParser parser = ASTParser.newParser(AST.JLS3); parser.setProject(unit.getJavaProject()); parser.setSource(unit); parser.setResolveBindings(true); ASTNode node = parser.createAST(monitor.newChild(1)); // The ASTNode must be a CompilationUnit, by design if (!(node instanceof CompilationUnit)) { status.addFatalError(String.format("Internal error: ASTNode class %s", //$NON-NLS-1$ node.getClass())); return null; } // ImportRewrite will allow us to add the new type to the imports and will resolve // what the Java source must reference, e.g. the FQCN or just the simple name. ImportRewrite importRewrite = ImportRewrite.create((CompilationUnit) node, true); String Rqualifier = packageName + ".R"; //$NON-NLS-1$ Rqualifier = importRewrite.addImport(Rqualifier); // Rewrite the AST itself via an ASTVisitor AST ast = node.getAST(); ASTRewrite astRewrite = ASTRewrite.create(ast); ArrayList<TextEditGroup> astEditGroups = new ArrayList<TextEditGroup>(); ReplaceStringsVisitor visitor = new ReplaceStringsVisitor(ast, astRewrite, astEditGroups, tokenString, Rqualifier, xmlStringId); node.accept(visitor); // Finally prepare the change set try { MultiTextEdit edit = new MultiTextEdit(); // Create the edit to change the imports, only if anything changed TextEdit subEdit = importRewrite.rewriteImports(monitor.newChild(1)); if (subEdit.hasChildren()) { edit.addChild(subEdit); } // Create the edit to change the Java source, only if anything changed subEdit = astRewrite.rewriteAST(); if (subEdit.hasChildren()) { edit.addChild(subEdit); } // Only create a change set if any edit was collected if (edit.hasChildren()) { change.setEdit(edit); // Create TextEditChangeGroups which let the user turn changes on or off // individually. This must be done after the change.setEdit() call above. for (TextEditGroup editGroup : astEditGroups) { TextEditChangeGroup group = new TextEditChangeGroup(change, editGroup); if (editGroup instanceof EnabledTextEditGroup) { group.setEnabled(((EnabledTextEditGroup) editGroup).isEnabled()); } change.addTextEditChangeGroup(group); } changes.add(change); } monitor.worked(1); if (changes.size() > 0) { return changes; } } catch (CoreException e) { // ImportRewrite.rewriteImports failed. status.addFatalError(e.getMessage()); } return null; } // ---- /** * Step 3 of 3 of the refactoring: returns the {@link Change} that will be able to do the * work and creates a descriptor that can be used to replay that refactoring later. * * @see org.eclipse.ltk.core.refactoring.Refactoring#createChange(org.eclipse.core.runtime.IProgressMonitor) * * @throws CoreException */ @Override public Change createChange(IProgressMonitor monitor) throws CoreException, OperationCanceledException { try { monitor.beginTask("Applying changes...", 1); CompositeChange change = new CompositeChange(getName(), mChanges.toArray(new Change[mChanges.size()])) { @Override public ChangeDescriptor getDescriptor() { String comment = String.format("Extracts string '%1$s' into R.string.%2$s", mTokenString, mXmlStringId); ExtractStringDescriptor desc = new ExtractStringDescriptor(mProject.getName(), //project comment, //description comment, //comment createArgumentMap()); return new RefactoringChangeDescriptor(desc); } }; monitor.worked(1); return change; } finally { monitor.done(); } } /** * Given a file project path, returns its resource in the same project than the * compilation unit. The resource may not exist. */ private IResource getTargetXmlResource(String xmlFileWsPath) { IResource resource = mProject.getFile(xmlFileWsPath); return resource; } }