Attachment #234481 for bug #224959




 *******************************************************************************/
package org.eclipse.ltk.core.refactoring.tests.resource;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import junit.framework.Test;
import junit.framework.TestCase;

import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.resource.CreateFileChange;
import org.eclipse.ltk.core.refactoring.resource.DeleteResourcesDescriptor;
import org.eclipse.ltk.core.refactoring.resource.MoveResourceChange;
import org.eclipse.ltk.core.refactoring.resource.MoveResourcesDescriptor;

		Change undoChange= perform(new MoveResourceChange(testFolder, destination));


		IFolder movedResource= (IFolder)assertMove(testFolder, destination, null);
		assertTrue(movedResource.getFile("myFile.txt").exists());

		perform(undoChange);

		IFolder destination= fProject.createFolder("dest");

		RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);
		MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor)contribution.createDescriptor();

		descriptor.setResourcesToMove(new IResource[] { file });
		descriptor.setDestination(destination);

		IFolder destination= fProject.createFolder("dest");

		RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);
		MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor)contribution.createDescriptor();

		descriptor.setResourcesToMove(new IResource[] { testFolder });
		descriptor.setDestination(destination);

		Change undoChange= perform(descriptor);

		IFolder movedResource= (IFolder)assertMove(testFolder, destination, null);
		assertTrue(movedResource.getFile("myFile.txt").exists());

		perform(undoChange);

		IFile file2= fProject.createFile(destination, "myFile.txt", content2);

		RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);
		MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor)contribution.createDescriptor();

		descriptor.setResourcesToMove(new IResource[] { file1 });
		descriptor.setDestination(destination);

	public void testDeleteRefactoring1_bug343584() throws Exception {
		IFolder testFolder= fProject.createFolder("test");
		fProject.createFile(testFolder, "myFile.txt", "hello");

		IProject testProject2= ResourcesPlugin.getWorkspace().getRoot().getProject(SimpleTestProject.TEST_PROJECT_NAME + "2");
		try {
			testProject2.create(null);

		IPath location= fProject.getProject().getLocation();
		IFolder testFolder= fProject.createFolder("test");
		fProject.createFile(testFolder, "myFile.txt", "hello");

		IWorkspace workspace= ResourcesPlugin.getWorkspace();
		String p2Name= "p2";
		IProjectDescription p2Description= workspace.newProjectDescription(p2Name);

		p2.create(p2Description, null);
		p2.open(null);
		IPath p2Location= p2.getLocation();

		RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(DeleteResourcesDescriptor.ID);
		DeleteResourcesDescriptor descriptor= (DeleteResourcesDescriptor)contribution.createDescriptor();

		descriptor.setDeleteContents(true);
		descriptor.setResources(new IResource[] { fProject.getProject(), p2 });

		perform(descriptor);

		assertFalse(fProject.getProject().exists());
		assertFalse(p2.exists());

		assertFalse(location.toFile().exists());
		assertFalse(p2Location.toFile().exists());
	}

	public void testDeleteRefactoring3_bug343584() throws Exception {
		IPath location= fProject.getProject().getLocation();
		IFolder testFolder= fProject.createFolder("test");
		IFile file= fProject.createFile(testFolder, "myFile.txt", "hello");
		IPath fileLocation= file.getLocation();

		IWorkspace workspace= ResourcesPlugin.getWorkspace();
		String p2Name= "p2";
		IProjectDescription p2Description= workspace.newProjectDescription(p2Name);

		p2.create(p2Description, null);
		p2.open(null);
		IPath p2Location= p2.getLocation();

		try {
			RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(DeleteResourcesDescriptor.ID);
			DeleteResourcesDescriptor descriptor= (DeleteResourcesDescriptor)contribution.createDescriptor();

			descriptor.setDeleteContents(false);
			descriptor.setResources(new IResource[] { fProject.getProject(), p2 });

			perform(descriptor);

			assertFalse(fProject.getProject().exists());
			assertFalse(p2.exists());

			assertTrue(location.toFile().exists());
			assertTrue(fileLocation.toFile().exists());
			assertTrue(p2Location.toFile().exists());

		} finally {
			EFS.getLocalFileSystem().getStore(location).delete(EFS.NONE, null);
			EFS.getLocalFileSystem().getStore(p2Location).delete(EFS.NONE, null);
		}
	}

	/*
	 * Creates a file in the project's root.
	 */
	public void testCreateFileChange1() throws Exception {
		String content= "hello";

		IFile file= fProject.getProject().getFile("myFile.txt");
		InputStream inputStream= new ByteArrayInputStream(content.getBytes());

		Change undoChange= perform(new CreateFileChange(file, inputStream));

		assertTrue(file.exists());
		assertEquals(content, fProject.getContent(file));

		perform(undoChange);

		assertFalse(file.exists());
	}

	/*
	 * Updates an existing file in the project's root.
	 */
	public void testCreateFileChange2() throws Exception {
		String oldContent= "hi";
		String newContent= "hello";

		IFile file= fProject.createFile(fProject.getProject(), "myFile.txt", oldContent);
		InputStream inputStream= new ByteArrayInputStream(newContent.getBytes());

		Change undoChange= perform(new CreateFileChange(file, inputStream));

		assertTrue(file.exists());
		assertEquals(newContent, fProject.getContent(file));

		perform(undoChange);

		assertTrue(file.exists());
		assertEquals(oldContent, fProject.getContent(file));
	}

	/*
	 * Updates an existing file in the project's root, but the overwrite flag
	 * is set to false.
	 */
	public void testCreateFileChange3() throws Exception {
		String oldContent= "hi";
		String newContent= "hello";

		IFile file= fProject.createFile(fProject.getProject(), "myFile.txt", oldContent);
		InputStream inputStream= new ByteArrayInputStream(newContent.getBytes());

		Change change= new CreateFileChange(file, inputStream, false);
		assertTrue(change.isValid(null).hasFatalError());
	}

	/*
	 * Creates a file in a deep folder structure where some folders do not
	 * exist yet.
	 */
	public void testCreateFileChange4() throws Exception {
		String content= "hello";

		IFolder existingFolder= fProject.createFolder("test");
		IFolder newFolder1= existingFolder.getFolder("foo");
		IFolder newFolder2= newFolder1.getFolder("bar");
		IFile file= newFolder2.getFile("myFile.txt");
		InputStream inputStream= new ByteArrayInputStream(content.getBytes());

		Change undoChange= perform(new CreateFileChange(file, inputStream));

		assertTrue(existingFolder.exists());
		assertTrue(newFolder1.exists());
		assertTrue(newFolder2.exists());
		assertTrue(file.exists());
		assertEquals(content, fProject.getContent(file));

		perform(undoChange);

		assertFalse(file.exists());
		assertFalse(newFolder2.exists());
		assertFalse(newFolder1.exists());
		assertTrue(existingFolder.exists());
	}

	private Change perform(Change change) throws CoreException {
		PerformChangeOperation op= new PerformChangeOperation(change);
		op.run(null);

		assertTrue(res.getType() == source.getType());

		if (res instanceof IFile) {
			assertTrue(content.equals(fProject.getContent((IFile)res)));
		}
		return res;
	}


}




/*******************************************************************************
 * Copyright (c) 2013 Zend Technologies Ltd 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:
 *     Zend Technologies Ltd - initial API and implementation
 *******************************************************************************/
package org.eclipse.ltk.core.refactoring.resource;

import java.io.IOException;
import java.io.InputStream;
import java.net.URI;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;

import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.internal.core.refactoring.BasicElementLabels;
import org.eclipse.ltk.internal.core.refactoring.Messages;
import org.eclipse.ltk.internal.core.refactoring.RefactoringCoreMessages;

/**
 * {@link Change} that creates a file.
 * 
 * @since 3.7
 */
public class CreateFileChange extends ResourceChange {

	private IFile fFile;

	private InputStream fInputStream;

	private boolean fOverwrite;

	/**
	 * Create new file.
	 * 
	 * <p>
	 * If there is an existing file on the specified path then it will be replaced with the new
	 * file. Calling this constructor is the same as calling
	 * <code>CreateFileChange(path, inputStream, true)</code>.
	 * </p>
	 * 
	 * @param file handle to for the new file
	 * @param inputStream content for the new file
	 */
	public CreateFileChange(IFile file, InputStream inputStream) {
		this(file, inputStream, true);
	}

	/**
	 * Create new file.
	 * 
	 * @param file handle to for the new file
	 * @param inputStream content for the new file
	 * @param overwrite whether an existing file on the specified path should be replaced, or the
	 *            change should fail
	 */

	public CreateFileChange(IFile file, InputStream inputStream, boolean overwrite) {
		Assert.isNotNull(file, "file"); //$NON-NLS-1$
		Assert.isNotNull(inputStream, "inputStream"); //$NON-NLS-1$
		fFile= file;
		fInputStream= inputStream;
		fOverwrite= overwrite;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ltk.core.refactoring.resource.ResourceChange#getModifiedResource()
	 */
	protected IResource getModifiedResource() {
		return fFile;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ltk.core.refactoring.Change#getName()
	 */
	public String getName() {
		String message= (fFile.exists()) ? RefactoringCoreMessages.CreateFileChange_update_file
				: RefactoringCoreMessages.CreateFileChange_create_file;
		return Messages.format(message, BasicElementLabels.getPathLabel(fFile.getFullPath(), false));
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ltk.core.refactoring.resource.ResourceChange#isValid(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException {
		RefactoringStatus result= new RefactoringStatus();

		URI location= fFile.getLocationURI();
		if (location == null) {
			result.addFatalError(Messages.format(
					RefactoringCoreMessages.CreateFileChange_error_unknownLocation,
					BasicElementLabels.getPathLabel(fFile.getFullPath(), false)));
			return result;
		}

		if (!fOverwrite) {
			IFileInfo jFile= EFS.getStore(location).fetchInfo();
			if (jFile.exists()) {
				result.addFatalError(Messages.format(
						RefactoringCoreMessages.CreateFileChange_error_exists,
						BasicElementLabels.getPathLabel(fFile.getFullPath(), false)));
				return result;
			}
		}

		return result;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ltk.core.refactoring.Change#perform(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public Change perform(IProgressMonitor pm) throws CoreException {
		if (pm == null)
			pm= new NullProgressMonitor();

		try {
			pm.beginTask(RefactoringCoreMessages.CreateFileChange_creating_resource, 2);

			if (fFile.exists()) {
				CompositeChange composite= new CompositeChange(getName());
				composite.add(new DeleteResourceChange(fFile.getFullPath(), true));
				composite.add(new CreateFileChange(fFile, fInputStream));
				return composite.perform(new SubProgressMonitor(pm, 1));
			} else {
				// create the parent folder if does not exist yet
				Change undo= createParentFolderIfNeeded(fFile, pm);

				// create the file
				fFile.create(fInputStream, false, new SubProgressMonitor(pm, 1));

				// the undo change is the delete change for the parent folder if one is created
				// otherwise - it is the delete change for the created file
				return (undo != null) ? undo :
						new DeleteResourceChange(fFile.getFullPath(), true);
			}
		} finally {
			try {
				fInputStream.close();
			} catch (IOException e) {
				throw new CoreException(new Status(IStatus.ERROR,
						RefactoringCore.ID_PLUGIN, e.getMessage(), e));
			} finally {
				pm.done();
			}
		}
	}

	private Change createParentFolderIfNeeded(IResource resource, IProgressMonitor pm) throws CoreException {
		IContainer parent= resource.getParent();

		if (parent == null)
			// the parent folder must not be null
			throw new IllegalStateException("parent folder is null"); //$NON-NLS-1$

		if (parent.getType() == IResource.PROJECT)
			// the parent is a project - assuming it exists
			return null;

		IFolder folder= (IFolder)parent;
		if (folder.exists())
			// the parent folder exists - nothing to do
			return null;

		// check if the parent of the parent also needs to be created
		Change undo= createParentFolderIfNeeded(folder, pm);

		// create the parent folder
		folder.create(false, true, pm);

		// the undo change is the delete change for the top-most created folder
		return (undo != null) ? undo :
				new DeleteResourceChange(folder.getFullPath(), true);
	}

}





	public static String ValidateEditChecker_failed;

	public static String CreateFileChange_creating_resource;

	public static String CreateFileChange_create_file;

	public static String CreateFileChange_update_file;

	public static String CreateFileChange_error_exists;

	public static String CreateFileChange_error_unknownLocation;

	static {
		NLS.initializeMessages(BUNDLE_NAME, RefactoringCoreMessages.class);
	}

Lines 156-158 Link Here

(-)a/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/internal/core/refactoring/RefactoringCoreMessages.properties (+6 lines)
156	MoveResourceProcessor_error_destination_not_exists=Destination does not exist	156	MoveResourceProcessor_error_destination_not_exists=Destination does not exist
157	MoveResourceProcessor_error_invalid_destination=Invalid parent	157	MoveResourceProcessor_error_invalid_destination=Invalid parent
158	MoveResourceProcessor_processor_name=Move Resources	158	MoveResourceProcessor_processor_name=Move Resources
		159
		160	CreateFileChange_creating_resource=Creating file...
		161	CreateFileChange_create_file=Create file ''{0}''
		162	CreateFileChange_update_file=Update file ''{0}''
		163	CreateFileChange_error_exists=File ''{0}'' already exists
		164	CreateFileChange_error_unknownLocation=The location for file ''{0}'' is unknown

Return to bug 224959

Lines 266-271 Link Here

(-)a/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/internal/core/refactoring/RefactoringCoreMessages.java (+10 lines)
266		266
267	public static String ValidateEditChecker_failed;	267	public static String ValidateEditChecker_failed;
268		268
		269	public static String CreateFileChange_creating_resource;
		270
		271	public static String CreateFileChange_create_file;
		272
		273	public static String CreateFileChange_update_file;
		274
		275	public static String CreateFileChange_error_exists;
		276
		277	public static String CreateFileChange_error_unknownLocation;
		278
269	static {	279	static {
270	NLS.initializeMessages(BUNDLE_NAME, RefactoringCoreMessages.class);	280	NLS.initializeMessages(BUNDLE_NAME, RefactoringCoreMessages.class);
271	}	281	}

Lines 11-17 Link Here

(-)a/org.eclipse.ltk.core.refactoring.tests/src/org/eclipse/ltk/core/refactoring/tests/resource/ResourceRefactoringTests.java (-25 / +111 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.ltk.core.refactoring.tests.resource;	12	package org.eclipse.ltk.core.refactoring.tests.resource;
13		13
		14	import java.io.ByteArrayInputStream;
14	import java.io.IOException;	15	import java.io.IOException;
		16	import java.io.InputStream;
15		17
16	import junit.framework.Test;	18	import junit.framework.Test;
17	import junit.framework.TestCase;	19	import junit.framework.TestCase;
Lines 41-46 Link Here
41	import org.eclipse.ltk.core.refactoring.RefactoringCore;	43	import org.eclipse.ltk.core.refactoring.RefactoringCore;
42	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;	44	import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
43	import org.eclipse.ltk.core.refactoring.RefactoringStatus;	45	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
		46	import org.eclipse.ltk.core.refactoring.resource.CreateFileChange;
44	import org.eclipse.ltk.core.refactoring.resource.DeleteResourcesDescriptor;	47	import org.eclipse.ltk.core.refactoring.resource.DeleteResourcesDescriptor;
45	import org.eclipse.ltk.core.refactoring.resource.MoveResourceChange;	48	import org.eclipse.ltk.core.refactoring.resource.MoveResourceChange;
46	import org.eclipse.ltk.core.refactoring.resource.MoveResourcesDescriptor;	49	import org.eclipse.ltk.core.refactoring.resource.MoveResourcesDescriptor;
Lines 95-101 Link Here
95	Change undoChange= perform(new MoveResourceChange(testFolder, destination));	98	Change undoChange= perform(new MoveResourceChange(testFolder, destination));
96		99
97		100
98	IFolder movedResource= (IFolder) assertMove(testFolder, destination, null);	101	IFolder movedResource= (IFolder)assertMove(testFolder, destination, null);
99	assertTrue(movedResource.getFile("myFile.txt").exists());	102	assertTrue(movedResource.getFile("myFile.txt").exists());
100		103
101	perform(undoChange);	104	perform(undoChange);
Lines 137-143 Link Here
137	IFolder destination= fProject.createFolder("dest");	140	IFolder destination= fProject.createFolder("dest");
138		141
139	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);	142	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);
140	MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor) contribution.createDescriptor();	143	MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor)contribution.createDescriptor();
141		144
142	descriptor.setResourcesToMove(new IResource[] { file });	145	descriptor.setResourcesToMove(new IResource[] { file });
143	descriptor.setDestination(destination);	146	descriptor.setDestination(destination);
Lines 161-174 Link Here
161	IFolder destination= fProject.createFolder("dest");	164	IFolder destination= fProject.createFolder("dest");
162		165
163	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);	166	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);
164	MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor) contribution.createDescriptor();	167	MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor)contribution.createDescriptor();
165		168
166	descriptor.setResourcesToMove(new IResource[] { testFolder });	169	descriptor.setResourcesToMove(new IResource[] { testFolder });
167	descriptor.setDestination(destination);	170	descriptor.setDestination(destination);
168		171
169	Change undoChange= perform(descriptor);	172	Change undoChange= perform(descriptor);
170		173
171	IFolder movedResource= (IFolder) assertMove(testFolder, destination, null);	174	IFolder movedResource= (IFolder)assertMove(testFolder, destination, null);
172	assertTrue(movedResource.getFile("myFile.txt").exists());	175	assertTrue(movedResource.getFile("myFile.txt").exists());
173		176
174	perform(undoChange);	177	perform(undoChange);
Lines 190-196 Link Here
190	IFile file2= fProject.createFile(destination, "myFile.txt", content2);	193	IFile file2= fProject.createFile(destination, "myFile.txt", content2);
191		194
192	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);	195	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(MoveResourcesDescriptor.ID);
193	MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor) contribution.createDescriptor();	196	MoveResourcesDescriptor descriptor= (MoveResourcesDescriptor)contribution.createDescriptor();
194		197
195	descriptor.setResourcesToMove(new IResource[] { file1 });	198	descriptor.setResourcesToMove(new IResource[] { file1 });
196	descriptor.setDestination(destination);	199	descriptor.setDestination(destination);
Lines 208-214 Link Here
208	public void testDeleteRefactoring1_bug343584() throws Exception {	211	public void testDeleteRefactoring1_bug343584() throws Exception {
209	IFolder testFolder= fProject.createFolder("test");	212	IFolder testFolder= fProject.createFolder("test");
210	fProject.createFile(testFolder, "myFile.txt", "hello");	213	fProject.createFile(testFolder, "myFile.txt", "hello");
211		214
212	IProject testProject2= ResourcesPlugin.getWorkspace().getRoot().getProject(SimpleTestProject.TEST_PROJECT_NAME + "2");	215	IProject testProject2= ResourcesPlugin.getWorkspace().getRoot().getProject(SimpleTestProject.TEST_PROJECT_NAME + "2");
213	try {	216	try {
214	testProject2.create(null);	217	testProject2.create(null);
Lines 233-239 Link Here
233	IPath location= fProject.getProject().getLocation();	236	IPath location= fProject.getProject().getLocation();
234	IFolder testFolder= fProject.createFolder("test");	237	IFolder testFolder= fProject.createFolder("test");
235	fProject.createFile(testFolder, "myFile.txt", "hello");	238	fProject.createFile(testFolder, "myFile.txt", "hello");
236		239
237	IWorkspace workspace= ResourcesPlugin.getWorkspace();	240	IWorkspace workspace= ResourcesPlugin.getWorkspace();
238	String p2Name= "p2";	241	String p2Name= "p2";
239	IProjectDescription p2Description= workspace.newProjectDescription(p2Name);	242	IProjectDescription p2Description= workspace.newProjectDescription(p2Name);
Lines 242-269 Link Here
242	p2.create(p2Description, null);	245	p2.create(p2Description, null);
243	p2.open(null);	246	p2.open(null);
244	IPath p2Location= p2.getLocation();	247	IPath p2Location= p2.getLocation();
245		248
246	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(DeleteResourcesDescriptor.ID);	249	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(DeleteResourcesDescriptor.ID);
247	DeleteResourcesDescriptor descriptor= (DeleteResourcesDescriptor) contribution.createDescriptor();	250	DeleteResourcesDescriptor descriptor= (DeleteResourcesDescriptor)contribution.createDescriptor();
248		251
249	descriptor.setDeleteContents(true);	252	descriptor.setDeleteContents(true);
250	descriptor.setResources(new IResource[] { fProject.getProject(), p2 });	253	descriptor.setResources(new IResource[] { fProject.getProject(), p2 });
251		254
252	perform(descriptor);	255	perform(descriptor);
253		256
254	assertFalse(fProject.getProject().exists());	257	assertFalse(fProject.getProject().exists());
255	assertFalse(p2.exists());	258	assertFalse(p2.exists());
256		259
257	assertFalse(location.toFile().exists());	260	assertFalse(location.toFile().exists());
258	assertFalse(p2Location.toFile().exists());	261	assertFalse(p2Location.toFile().exists());
259	}	262	}
260		263
261	public void testDeleteRefactoring3_bug343584() throws Exception {	264	public void testDeleteRefactoring3_bug343584() throws Exception {
262	IPath location= fProject.getProject().getLocation();	265	IPath location= fProject.getProject().getLocation();
263	IFolder testFolder= fProject.createFolder("test");	266	IFolder testFolder= fProject.createFolder("test");
264	IFile file= fProject.createFile(testFolder, "myFile.txt", "hello");	267	IFile file= fProject.createFile(testFolder, "myFile.txt", "hello");
265	IPath fileLocation= file.getLocation();	268	IPath fileLocation= file.getLocation();
266		269
267	IWorkspace workspace= ResourcesPlugin.getWorkspace();	270	IWorkspace workspace= ResourcesPlugin.getWorkspace();
268	String p2Name= "p2";	271	String p2Name= "p2";
269	IProjectDescription p2Description= workspace.newProjectDescription(p2Name);	272	IProjectDescription p2Description= workspace.newProjectDescription(p2Name);
Lines 272-300 Link Here
272	p2.create(p2Description, null);	275	p2.create(p2Description, null);
273	p2.open(null);	276	p2.open(null);
274	IPath p2Location= p2.getLocation();	277	IPath p2Location= p2.getLocation();
275		278
276	try {	279	try {
277	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(DeleteResourcesDescriptor.ID);	280	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(DeleteResourcesDescriptor.ID);
278	DeleteResourcesDescriptor descriptor= (DeleteResourcesDescriptor) contribution.createDescriptor();	281	DeleteResourcesDescriptor descriptor= (DeleteResourcesDescriptor)contribution.createDescriptor();
279		282
280	descriptor.setDeleteContents(false);	283	descriptor.setDeleteContents(false);
281	descriptor.setResources(new IResource[] { fProject.getProject(), p2 });	284	descriptor.setResources(new IResource[] { fProject.getProject(), p2 });
282		285
283	perform(descriptor);	286	perform(descriptor);
284		287
285	assertFalse(fProject.getProject().exists());	288	assertFalse(fProject.getProject().exists());
286	assertFalse(p2.exists());	289	assertFalse(p2.exists());
287		290
288	assertTrue(location.toFile().exists());	291	assertTrue(location.toFile().exists());
289	assertTrue(fileLocation.toFile().exists());	292	assertTrue(fileLocation.toFile().exists());
290	assertTrue(p2Location.toFile().exists());	293	assertTrue(p2Location.toFile().exists());
291		294
292	} finally {	295	} finally {
293	EFS.getLocalFileSystem().getStore(location).delete(EFS.NONE, null);	296	EFS.getLocalFileSystem().getStore(location).delete(EFS.NONE, null);
294	EFS.getLocalFileSystem().getStore(p2Location).delete(EFS.NONE, null);	297	EFS.getLocalFileSystem().getStore(p2Location).delete(EFS.NONE, null);
295	}	298	}
296	}	299	}
297		300
		301	/*
		302	* Creates a file in the project's root.
		303	*/
		304	public void testCreateFileChange1() throws Exception {
		305	String content= "hello";
		306
		307	IFile file= fProject.getProject().getFile("myFile.txt");
		308	InputStream inputStream= new ByteArrayInputStream(content.getBytes());
		309
		310	Change undoChange= perform(new CreateFileChange(file, inputStream));
		311
		312	assertTrue(file.exists());
		313	assertEquals(content, fProject.getContent(file));
		314
		315	perform(undoChange);
		316
		317	assertFalse(file.exists());
		318	}
		319
		320	/*
		321	* Updates an existing file in the project's root.
		322	*/
		323	public void testCreateFileChange2() throws Exception {
		324	String oldContent= "hi";
		325	String newContent= "hello";
		326
		327	IFile file= fProject.createFile(fProject.getProject(), "myFile.txt", oldContent);
		328	InputStream inputStream= new ByteArrayInputStream(newContent.getBytes());
		329
		330	Change undoChange= perform(new CreateFileChange(file, inputStream));
		331
		332	assertTrue(file.exists());
		333	assertEquals(newContent, fProject.getContent(file));
		334
		335	perform(undoChange);
		336
		337	assertTrue(file.exists());
		338	assertEquals(oldContent, fProject.getContent(file));
		339	}
		340
		341	/*
		342	* Updates an existing file in the project's root, but the overwrite flag
		343	* is set to false.
		344	*/
		345	public void testCreateFileChange3() throws Exception {
		346	String oldContent= "hi";
		347	String newContent= "hello";
		348
		349	IFile file= fProject.createFile(fProject.getProject(), "myFile.txt", oldContent);
		350	InputStream inputStream= new ByteArrayInputStream(newContent.getBytes());
		351
		352	Change change= new CreateFileChange(file, inputStream, false);
		353	assertTrue(change.isValid(null).hasFatalError());
		354	}
		355
		356	/*
		357	* Creates a file in a deep folder structure where some folders do not
		358	* exist yet.
		359	*/
		360	public void testCreateFileChange4() throws Exception {
		361	String content= "hello";
		362
		363	IFolder existingFolder= fProject.createFolder("test");
		364	IFolder newFolder1= existingFolder.getFolder("foo");
365	IFolder newFolder2= newFolder1.getFolder("bar");
366	IFile file= newFolder2.getFile("myFile.txt");
367	InputStream inputStream= new ByteArrayInputStream(content.getBytes());
368
369	Change undoChange= perform(new CreateFileChange(file, inputStream));
370
371	assertTrue(existingFolder.exists());
372	assertTrue(newFolder1.exists());
373	assertTrue(newFolder2.exists());
374	assertTrue(file.exists());
375	assertEquals(content, fProject.getContent(file));
376
377	perform(undoChange);
378
379	assertFalse(file.exists());
380	assertFalse(newFolder2.exists());
381	assertFalse(newFolder1.exists());
382	assertTrue(existingFolder.exists());
383	}
384
298	private Change perform(Change change) throws CoreException {	385	private Change perform(Change change) throws CoreException {
299	PerformChangeOperation op= new PerformChangeOperation(change);	386	PerformChangeOperation op= new PerformChangeOperation(change);
300	op.run(null);	387	op.run(null);
Lines 327-336 Link Here
327	assertTrue(res.getType() == source.getType());	414	assertTrue(res.getType() == source.getType());
328		415
329	if (res instanceof IFile) {	416	if (res instanceof IFile) {
330	assertTrue(content.equals(fProject.getContent((IFile) res)));	417	assertTrue(content.equals(fProject.getContent((IFile)res)));
331	}	418	}
332	return res;	419	return res;
333	}	420	}
334
335		421
336	}	422	}

Added Link Here

(-)a/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/core/refactoring/resource/CreateFileChange.java (+197 lines)
1	/*******************************************************************************
2	* Copyright (c) 2013 Zend Technologies Ltd and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Zend Technologies Ltd - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ltk.core.refactoring.resource;
12
13	import java.io.IOException;
14	import java.io.InputStream;
15	import java.net.URI;
16
17	import org.eclipse.core.filesystem.EFS;
18	import org.eclipse.core.filesystem.IFileInfo;
19
20	import org.eclipse.core.runtime.Assert;
21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.IStatus;
24	import org.eclipse.core.runtime.NullProgressMonitor;
25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.core.runtime.SubProgressMonitor;
27
28	import org.eclipse.core.resources.IContainer;
29	import org.eclipse.core.resources.IFile;
30	import org.eclipse.core.resources.IFolder;
31	import org.eclipse.core.resources.IResource;
32
33	import org.eclipse.ltk.core.refactoring.Change;
34	import org.eclipse.ltk.core.refactoring.CompositeChange;
35	import org.eclipse.ltk.core.refactoring.RefactoringCore;
36	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
37	import org.eclipse.ltk.internal.core.refactoring.BasicElementLabels;
38	import org.eclipse.ltk.internal.core.refactoring.Messages;
39	import org.eclipse.ltk.internal.core.refactoring.RefactoringCoreMessages;
40
41	/**
42	* {@link Change} that creates a file.
43	*
44	* @since 3.7
45	*/
46	public class CreateFileChange extends ResourceChange {
47
48	private IFile fFile;
49
50	private InputStream fInputStream;
51
52	private boolean fOverwrite;
53
54	/**
55	* Create new file.
56	*
57	* <p>
58	* If there is an existing file on the specified path then it will be replaced with the new
59	* file. Calling this constructor is the same as calling
60	* <code>CreateFileChange(path, inputStream, true)</code>.
61	* </p>
62	*
63	* @param file handle to for the new file
64	* @param inputStream content for the new file
65	*/
66	public CreateFileChange(IFile file, InputStream inputStream) {
67	this(file, inputStream, true);
68	}
69
70	/**
71	* Create new file.
72	*
73	* @param file handle to for the new file
74	* @param inputStream content for the new file
75	* @param overwrite whether an existing file on the specified path should be replaced, or the
76	* change should fail
77	*/
78
79	public CreateFileChange(IFile file, InputStream inputStream, boolean overwrite) {
80	Assert.isNotNull(file, "file"); //$NON-NLS-1$
81	Assert.isNotNull(inputStream, "inputStream"); //$NON-NLS-1$
82	fFile= file;
83	fInputStream= inputStream;
84	fOverwrite= overwrite;
85	}
86
87	/* (non-Javadoc)
88	* @see org.eclipse.ltk.core.refactoring.resource.ResourceChange#getModifiedResource()
89	*/
90	protected IResource getModifiedResource() {
91	return fFile;
92	}
93
94	/* (non-Javadoc)
95	* @see org.eclipse.ltk.core.refactoring.Change#getName()
96	*/
97	public String getName() {
98	String message= (fFile.exists()) ? RefactoringCoreMessages.CreateFileChange_update_file
99	: RefactoringCoreMessages.CreateFileChange_create_file;
100	return Messages.format(message, BasicElementLabels.getPathLabel(fFile.getFullPath(), false));
101	}
102
103	/*
104	* (non-Javadoc)
105	* @see org.eclipse.ltk.core.refactoring.resource.ResourceChange#isValid(org.eclipse.core.runtime.IProgressMonitor)
106	*/
107	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException {
108	RefactoringStatus result= new RefactoringStatus();
109
110	URI location= fFile.getLocationURI();
111	if (location == null) {
112	result.addFatalError(Messages.format(
113	RefactoringCoreMessages.CreateFileChange_error_unknownLocation,
114	BasicElementLabels.getPathLabel(fFile.getFullPath(), false)));
115	return result;
116	}
117
118	if (!fOverwrite) {
119	IFileInfo jFile= EFS.getStore(location).fetchInfo();
120	if (jFile.exists()) {
121	result.addFatalError(Messages.format(
122	RefactoringCoreMessages.CreateFileChange_error_exists,
123	BasicElementLabels.getPathLabel(fFile.getFullPath(), false)));
124	return result;
125	}
126	}
127
128	return result;
129	}
130
131	/* (non-Javadoc)
132	* @see org.eclipse.ltk.core.refactoring.Change#perform(org.eclipse.core.runtime.IProgressMonitor)
133	*/
134	public Change perform(IProgressMonitor pm) throws CoreException {
135	if (pm == null)
136	pm= new NullProgressMonitor();
137
138	try {
139	pm.beginTask(RefactoringCoreMessages.CreateFileChange_creating_resource, 2);
140
141	if (fFile.exists()) {
142	CompositeChange composite= new CompositeChange(getName());
143	composite.add(new DeleteResourceChange(fFile.getFullPath(), true));
144	composite.add(new CreateFileChange(fFile, fInputStream));
145	return composite.perform(new SubProgressMonitor(pm, 1));
146	} else {
147	// create the parent folder if does not exist yet
148	Change undo= createParentFolderIfNeeded(fFile, pm);
149
150	// create the file
151	fFile.create(fInputStream, false, new SubProgressMonitor(pm, 1));
152
153	// the undo change is the delete change for the parent folder if one is created
154	// otherwise - it is the delete change for the created file
155	return (undo != null) ? undo :
156	new DeleteResourceChange(fFile.getFullPath(), true);
157	}
158	} finally {
159	try {
160	fInputStream.close();
161	} catch (IOException e) {
162	throw new CoreException(new Status(IStatus.ERROR,
163	RefactoringCore.ID_PLUGIN, e.getMessage(), e));
164	} finally {
165	pm.done();
166	}
167	}
168	}
169
170	private Change createParentFolderIfNeeded(IResource resource, IProgressMonitor pm) throws CoreException {
171	IContainer parent= resource.getParent();
172
173	if (parent == null)
174	// the parent folder must not be null
175	throw new IllegalStateException("parent folder is null"); //$NON-NLS-1$
176
177	if (parent.getType() == IResource.PROJECT)
178	// the parent is a project - assuming it exists
179	return null;
180
181	IFolder folder= (IFolder)parent;
182	if (folder.exists())
183	// the parent folder exists - nothing to do
184	return null;
185
186	// check if the parent of the parent also needs to be created
187	Change undo= createParentFolderIfNeeded(folder, pm);
188
189	// create the parent folder
190	folder.create(false, true, pm);
191
192	// the undo change is the delete change for the top-most created folder
193	return (undo != null) ? undo :
194	new DeleteResourceChange(folder.getFullPath(), true);
195	}
196
197	}