protected void addArchiveDescriptor(
IRepositoryStore<IRepositoryFileStore> sourceStore, List<IResource> resourcesToExport) {
IFile descFile = sourceStore.getResource().getFile(DESCRIPTOR_FILE);
if (descFile.exists()) {
try {
descFile.delete(true, Repository.NULL_PROGRESS_MONITOR);
} catch (CoreException e) {
BonitaStudioLog.error(e);
}
}
final Properties properties = new Properties();
properties.put(VERSION, ProductVersion.CURRENT_VERSION);
properties.put(TYPE, getArchiveType());
FileOutputStream out = null;
try {
out = new FileOutputStream(descFile.getLocation().toFile());
properties.store(out, null);
resourcesToExport.add(descFile);
cleanAfterExport.add(descFile);
} catch (Exception e) {
BonitaStudioLog.error(e);
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
BonitaStudioLog.error(e);
}
}
sourceStore.refresh();
}
}
/** https://bugs.eclipse.org/bugs/show_bug.cgi?id=400193 */
@Test
public void testSourceRelativeOutput() throws Exception {
IProject project = testHelper.getProject();
String srcFolder = "/foo/bar/bug";
JavaProjectSetupUtil.addSourceFolder(JavaCore.create(project), srcFolder);
String path = srcFolder + "/Foo.xtend";
String fullFileName = project.getName() + path;
IFile sourceFile = testHelper.createFileImpl(fullFileName, "class Foo {}");
assertTrue(sourceFile.exists());
waitForBuild();
IFile generatedFile = project.getFile("foo/bar/xtend-gen/Foo.java");
assertTrue(generatedFile.exists());
IFile traceFile = testHelper.getProject().getFile("foo/bar/xtend-gen/.Foo.java._trace");
assertTrue(traceFile.exists());
IFile classFile = testHelper.getProject().getFile("/bin/Foo.class");
assertTrue(classFile.exists());
List<IPath> traceFiles = traceMarkers.findTraceFiles(sourceFile);
assertTrue(traceFiles.contains(traceFile.getFullPath()));
sourceFile.delete(false, new NullProgressMonitor());
waitForBuild();
assertFalse(generatedFile.exists());
assertFalse(traceFile.exists());
}
@Override
protected void build(IFile result, IProgressMonitor monitor) throws CoreException {
IFile file = getRelated(result, "owl");
if (!file.exists()) {
clean(result, monitor);
return;
}
CIMBuilder.removeMarkers(file);
ProfileValidator checker =
new ProfileValidator(getProfileModel(file), getBackgroundModel(file));
try {
checker.run();
} catch (IOException e) {
throw error("Failed to validate profile", e);
} catch (ParserException e) {
throw error("Failed to validate profile", e);
}
if (checker.hasErrors()) {
write(checker.getLog(), null, false, result, IO.RDF_XML_WITH_NODEIDS, monitor);
result.setDerived(true);
CIMBuilder.addMarker(
file,
"Profile " + file.getName() + " has consistency errors with respect to its schema");
} else {
if (result.exists()) result.delete(false, monitor);
}
}
public static IFile LinkFile(String path) {
IWorkspace ws = ResourcesPlugin.getWorkspace();
IProject project = ws.getRoot().getProject("tmp");
if (!project.exists())
try {
project.create(null);
} catch (CoreException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (!project.isOpen())
try {
project.open(null);
} catch (CoreException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
IPath location = new Path(path);
IFile file = project.getFile(location.lastSegment());
try {
file.delete(true, null);
} catch (CoreException e1) {
}
try {
file.createLink(location, IResource.NONE, null);
} catch (CoreException e) {
}
return file;
}
private void handleDeleteFile() {
Object selection = ((TreeSelection) fileTree.getSelection()).getFirstElement();
if (!(selection instanceof IFile)) return;
IFile file = (IFile) selection;
int option =
new MessageDialog(
getShell(),
"Delete " + file.getName() + "?",
null,
"Are you sure you want to delete "
+ "the configuration file: "
+ file.getName()
+ "?",
MessageDialog.QUESTION,
new String[] {"Yes", "No"},
1)
.open();
if (option != 0) return;
try {
file.delete(true, true, null);
} catch (CoreException e) {
VJP.logError("Could not delete file.", e);
}
updateTree();
}
public void testResourceDelta() throws CoreException {
IProject[] prjs = new IProject[] {fProject};
fProject.create(new NullProgressMonitor());
fProject.open(new NullProgressMonitor());
IFile[] files = ResourceLookup.findFilesByName(new Path("abc.h"), prjs, true);
assertEquals(0, files.length);
IFolder f1 = createFolder(fProject, "folder1");
createFolder(fProject, "folder2");
IFile f2 = createFile(fProject, "abc.h");
files = ResourceLookup.findFilesByName(new Path("abc.h"), prjs, true);
assertEquals(1, files.length);
createFile(fProject, "folder1/abc.h");
files = ResourceLookup.findFilesByName(new Path("abc.h"), prjs, true);
assertEquals(2, files.length);
createFile(fProject, "folder2/abC.h");
files = ResourceLookup.findFilesByName(new Path("abc.h"), prjs, true);
assertEquals(3, files.length);
f1.delete(true, new NullProgressMonitor());
files = ResourceLookup.findFilesByName(new Path("abc.h"), prjs, true);
assertEquals(2, files.length);
f2.delete(true, new NullProgressMonitor());
files = ResourceLookup.findFilesByName(new Path("abc.h"), prjs, true);
assertEquals(1, files.length);
}
@Test
public void testBuild() throws Exception {
IFile sourceFile = testHelper.createFile("test/Test", "package test\nclass Test {}");
assertTrue(sourceFile.exists());
waitForBuild();
IFile targetFile = testHelper.getProject().getFile("/xtend-gen/test/Test.java");
assertTrue(targetFile.exists());
assertFalse(fileIsEmpty(targetFile));
IFile traceFile = testHelper.getProject().getFile("/xtend-gen/test/.Test.java._trace");
assertTrue(traceFile.exists());
assertFalse(fileIsEmpty(traceFile));
IFile classFile = testHelper.getProject().getFile("/bin/test/Test.class");
assertTrue(classFile.exists());
assertFalse(fileIsEmpty(classFile));
List<IPath> traceFiles = traceMarkers.findTraceFiles(sourceFile);
assertTrue(traceFiles.contains(traceFile.getFullPath()));
sourceFile.delete(true, null);
waitForBuild();
cleanBuild();
assertTrue(targetFile.getParent().exists());
assertFalse(targetFile.exists());
assertFalse(traceFile.exists());
assertFalse(classFile.exists());
}
private void stackTracingWasChanged(boolean enabled) {
IPreferenceStore store = CxxTestPlugin.getDefault().getPreferenceStore();
String driverFile = store.getString(CxxTestPlugin.CXXTEST_PREF_DRIVER_FILENAME);
IExtraOptionsUpdater updater = CxxTestPlugin.getDefault().getExtraOptionsUpdater();
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IProject[] projects = workspace.getRoot().getProjects();
for (IProject project : projects) {
if (!project.isOpen()) {
continue;
}
try {
if (project.hasNature(CxxTestPlugin.CXXTEST_NATURE)) {
IFile driver = project.getFile(driverFile);
if (driver != null) {
driver.delete(true, null);
}
updater.updateOptions(project);
}
} catch (CoreException e) {
e.printStackTrace();
}
}
}
/**
* Deletes a set of files from the file system, and also their parent folders if those become
* empty during this process.
*
* @param nameSet set of file paths
* @param monitor progress monitor
* @throws CoreException if an error occurs
*/
private void deleteFiles(final Set<IPath> nameSet, IProgressMonitor monitor)
throws CoreException {
if (nameSet == null || nameSet.isEmpty()) {
return;
}
Set<IContainer> subFolders = new HashSet<IContainer>();
for (IPath filePath : nameSet) {
// Generate new path
IFile currentFile = project.getFile(filePath);
if (currentFile.exists()) {
// Retrieve parent folder and store for deletion
IContainer folder = currentFile.getParent();
subFolders.add(folder);
currentFile.delete(true, monitor);
}
monitor.worked(1);
}
// Delete parent folders, if they are empty
for (IContainer folder : subFolders) {
if (folder.exists() && folder.members().length == 0) {
folder.delete(true, monitor);
}
monitor.worked(1);
}
}
@Override
protected void tearDown() throws Exception {
try {
for (ITextEditor editor : editors) {
// Need to force the editor shut!
if (editor != null) {
if (Display.getCurrent() != null) {
editor.getSite().getPage().closeEditor(editor, false);
} else {
editor.close(false);
}
}
}
for (IFile file : files) {
// Delete the generated file
file.delete(true, new NullProgressMonitor());
}
// Delete the generated project
project.delete(true, new NullProgressMonitor());
} finally {
editors = null;
files = null;
project = null;
super.tearDown();
}
}
private void replaceContent(IFile f, String content) {
try {
f.delete(true, new NullProgressMonitor());
} catch (CoreException ce) {
LOGGER.log(Level.WARNING, ce.getMessage(), ce);
}
InputStream is = null;
try {
is = EAPFromWSDLTest.class.getResourceAsStream(content);
f.create(is, true, new NullProgressMonitor());
} catch (CoreException ce) {
LOGGER.log(Level.WARNING, ce.getMessage(), ce);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException ioe) {
// ignore
}
}
}
try {
ResourcesPlugin.getWorkspace()
.getRoot()
.refreshLocal(IWorkspaceRoot.DEPTH_INFINITE, new NullProgressMonitor());
} catch (CoreException e) {
LOGGER.log(Level.WARNING, e.getMessage(), e);
}
util.waitForNonIgnoredJobs();
}
public void overwriteTemplate(Template template) throws CoreException {
try {
// get the directory
String projectName = folderSelected.getProject().getName();
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject project = root.getProject(projectName);
IPath pathFolder = folderSelected.getProjectRelativePath();
String templateFileName = template.getFileName();
DataHandler dh = template.getContent();
InputStream is = dh.getInputStream();
IPath pathNewFile = pathFolder.append(templateFileName);
IFile newFile = project.getFile(pathNewFile);
// create new File
if (newFile.exists()) {
newFile.delete(true, null);
}
newFile.create(is, true, null);
// set the dirty property to true
newFile.setPersistentProperty(SpagoBIStudioConstants.DIRTY_MODEL, "true");
} catch (IOException e1) {
MessageDialog.openError(
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
"Error",
"Error in writing the file");
logger.error("Error in writing the file", e1);
return;
}
}
/**
* (non-Javadoc)
*
* @see org.eclipse.ice.core.iCore.ICore#importFile(java.net.URI,
* org.eclipse.core.resources.IProject)
*/
@Override
public void importFile(URI file, IProject project) {
// Only do this if the file is good
if (file != null) {
// Get the file handle
IPath path = (new Path(file.toString()));
IFile fileInProject = project.getFile(path.lastSegment());
// Get the paths and convert them to strings
IPath fullPathInProject = fileInProject.getLocation();
String path1 = path.toString(), path2 = fullPathInProject.toString();
// Remove devices ids and other such things from the path strings
path1 = path1.substring(path1.lastIndexOf(":") + 1);
path2 = path2.substring(path2.lastIndexOf(":") + 1);
// Only manipulate the file if it is not already in the workspace.
// It is completely reasonable to stick the file in the workspace
// and then "import" it, so a simple check here relieves some
// heartburn I would no doubt otherwise endure.
if (!path1.equals(path2)) {
// If the project space contains a file by the same name, but
// with a different absolute path, delete that file.
if (fileInProject.exists()) {
try {
fileInProject.delete(true, null);
} catch (CoreException e) {
// Complain and don't do anything else.
logger.info("Core Message: " + "Unable to import file.");
logger.error(getClass().getName() + " Exception!", e);
return;
}
}
try {
// Open a stream of the file
FileInputStream fileStream = new FileInputStream(new File(file));
// Import the file
fileInProject.create(fileStream, true, null);
} catch (FileNotFoundException e) {
// Complain and don't do anything else.
logger.info("Core Message: " + "Unable to import file.");
logger.error(getClass().getName() + " Exception!", e);
return;
} catch (CoreException e) {
// Complain and don't do anything else.
logger.info("Core Message: " + "Unable to import file.");
logger.error(getClass().getName() + " Exception!", e);
return;
}
}
// Refresh all of the Items
itemManager.reloadItemData();
// Drop some debug info.
if (System.getProperty("DebugICE") != null) {
logger.info("Core Message: " + "Imported file " + file.toString());
}
} else {
logger.info("File could not be imported into project because the File URI was not valid.");
}
}
/**
* Moves a file to the output directory with a new name.
*
* @param project the current project
* @param sourceFile output file to be moved
* @param destDir the destination directory of the file
* @param destName the new name of the file
* @param monitor progress monitor
* @throws CoreException if an error occurs
* @return file in the new location
*/
private static IFile moveFile(
IProject project,
IFile sourceFile,
IContainer destContainer,
String destName,
IProgressMonitor monitor)
throws CoreException {
if (sourceFile != null && sourceFile.exists() && destName != null) {
final IPath destRelPath = new Path(destName);
final IFile dest = destContainer.getFile(destRelPath);
if (dest.exists()) {
File outFile = new File(sourceFile.getLocationURI());
File destFile = new File(dest.getLocationURI());
try {
// Try to move the content instead of deleting the old file
// and replace it by the new one. This is better for some
// viewers like Sumatrapdf
FileOutputStream out = new FileOutputStream(destFile);
out.getChannel().tryLock();
BufferedInputStream in = new BufferedInputStream(new FileInputStream(outFile));
byte[] buf = new byte[4096];
int l;
while ((l = in.read(buf)) != -1) {
out.write(buf, 0, l);
}
in.close();
out.close();
sourceFile.delete(true, monitor);
} catch (IOException e) {
// try to delete and move the file
dest.delete(true, monitor);
sourceFile.move(dest.getFullPath(), true, monitor);
}
} else {
// move the file
sourceFile.move(dest.getFullPath(), true, monitor);
}
monitor.worked(1);
return dest;
} else {
return null;
}
}
public static IFile getDataFileForInput(final IEditorInput input) {
final IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
if (input instanceof ToscaDiagramEditorInput) {
final ToscaDiagramEditorInput tdei = (ToscaDiagramEditorInput) input;
return tdei.getToscaFile();
} else if (input instanceof DiagramEditorInput) {
final DiagramEditorInput dei = (DiagramEditorInput) input;
IPath path = new Path(dei.getUri().trimFragment().toPlatformString(true));
return recreateDataFile(path);
} else if (input instanceof FileEditorInput) {
final FileEditorInput fei = (FileEditorInput) input;
return fei.getFile();
} else if (input instanceof IURIEditorInput) {
// opened externally to Eclipse
final IURIEditorInput uei = (IURIEditorInput) input;
final java.net.URI uri = uei.getURI();
final String path = uri.getPath();
try {
final IProject importProject = root.getProject("import"); // $NON-NLS-1$
if (!importProject.exists()) {
importProject.create(null);
}
importProject.open(null);
final InputStream is = new FileInputStream(path);
final String fileName;
if (path.contains("/")) { // $NON-NLS-1$
fileName = path.substring(path.lastIndexOf("/") + 1); // $NON-NLS-1$
} else {
fileName = path.substring(path.lastIndexOf("\\") + 1); // $NON-NLS-1$
}
IFile importFile = importProject.getFile(fileName);
if (importFile.exists()) {
importFile.delete(true, null);
}
importFile.create(is, true, null);
return importProject.getFile(fileName);
} catch (CoreException exception) {
exception.printStackTrace();
} catch (FileNotFoundException exception) {
exception.printStackTrace();
}
}
return null;
}
/**
* Deletes the output file.
*
* @param monitor progress monitor
* @throws CoreException if an error occurs
*/
public void cleanOutputFile(IProgressMonitor monitor) throws CoreException {
monitor.subTask(TexlipsePlugin.getResourceString("builderSubTaskCleanOutput"));
IFile outputFile = getSelectedOutputFile();
if (outputFile != null && outputFile.exists()) {
outputFile.delete(true, monitor);
}
monitor.worked(1);
}
@Test
public void testShouldLoadFromStorage() {
try {
StringConcatenation _builder = new StringConcatenation();
_builder.append("package mypack");
_builder.newLine();
_builder.newLine();
_builder.append("class MyClass {");
_builder.newLine();
_builder.append("\t");
_builder.append("public def void foo() {");
_builder.newLine();
_builder.append("\t");
_builder.append("}");
_builder.newLine();
_builder.append("}");
_builder.newLine();
final IFile file = this.helper.createFile("mypack/MyClass.xtend", _builder.toString());
IResourcesSetupUtil.waitForAutoBuild();
final URI uri = this.uriMapper.getUri(file);
IProject _project = file.getProject();
final ResourceSet resourceSet = this.resourceSetProvider.get(_project);
SourceLevelURIsAdapter.setSourceLevelUris(
resourceSet, Collections.<URI>unmodifiableList(CollectionLiterals.<URI>newArrayList()));
Resource _createResource = resourceSet.createResource(uri);
final StorageAwareResource resource = ((StorageAwareResource) _createResource);
final Procedure0 _function =
new Procedure0() {
@Override
public void apply() {
IResourceStorageFacade _resourceStorageFacade = resource.getResourceStorageFacade();
boolean _shouldLoadFromStorage =
_resourceStorageFacade.shouldLoadFromStorage(resource);
Assert.assertTrue(_shouldLoadFromStorage);
}
};
this.doWorkInJob(_function);
NullProgressMonitor _nullProgressMonitor = new NullProgressMonitor();
file.delete(true, _nullProgressMonitor);
IResourcesSetupUtil.waitForAutoBuild();
final Procedure0 _function_1 =
new Procedure0() {
@Override
public void apply() {
IResourceStorageFacade _resourceStorageFacade = resource.getResourceStorageFacade();
boolean _shouldLoadFromStorage =
_resourceStorageFacade.shouldLoadFromStorage(resource);
Assert.assertFalse(_shouldLoadFromStorage);
}
};
this.doWorkInJob(_function_1);
} catch (Throwable _e) {
throw Exceptions.sneakyThrow(_e);
}
}
private void renameResource() {
try {
String newName = queryNewResourceName(resSelectedResource);
if (newName == null || newName.equals("")) // $NON-NLS-1$
return;
IPath newPath = resSelectedResource.getFullPath().removeLastSegments(1).append(newName);
IWorkspaceRoot workspaceRoot = resSelectedResource.getWorkspace().getRoot();
IProgressMonitor monitor = new NullProgressMonitor();
IResource newResource = workspaceRoot.findMember(newPath);
IWorkbenchPage iwbp = getIWorkbenchPage();
// determine if file open in workspace...
boolean wasOpen = isEditorOpen(iwbp, resSelectedResource);
// do the move:
if (newResource != null) {
if (checkOverwrite(getShell(), newResource)) {
if (resSelectedResource.getType() == IResource.FILE
&& newResource.getType() == IResource.FILE) {
IFile file = (IFile) resSelectedResource;
IFile newFile = (IFile) newResource;
// need to check for the case that a file we are overwriting is open,
// and re-open it if it is, regardless of whether the old file was open
wasOpen = isEditorOpen(iwbp, newResource);
if (validateEdit(file, newFile, getShell())) {
newFile.setContents(file.getContents(), IResource.KEEP_HISTORY, monitor);
file.delete(IResource.KEEP_HISTORY, monitor);
}
}
}
} else {
resSelectedResource.move(
newPath,
IResource.KEEP_HISTORY | IResource.SHALLOW,
new SubProgressMonitor(monitor, 50));
}
reOpenEditor(wasOpen, newName, iwbp);
} catch (CoreException err) {
ModelerCore.Util.log(IStatus.ERROR, err, err.getMessage());
}
}
public static void deleteModule(final IErlModule module) throws CoreException {
final String scannerName = module.getScannerName();
final IFile file = (IFile) module.getResource();
if (file != null) {
file.delete(true, null);
}
final IPath stateDir = new Path(ErlangEngine.getInstance().getStateDir());
// FIXME this code should not know about caches!
final String cacheExts[] = {".noparse", ".refs", ".scan"};
for (final String ext : cacheExts) {
final IPath p = stateDir.append(scannerName + ext);
final File f = new File(p.toOSString());
f.delete();
}
module.dispose();
modulesAndIncludes.remove(module);
}
@Test
public void rebarBuilderShouldWork() throws CoreException {
final IFolder folder = (IFolder) prj.findMember("src");
final IFile app = folder.getFile("z.app.src");
app.create(
new StringBufferInputStream(
"{application, builders,[{description, \"\"},{vsn, \"1\"},"
+ "{registered, []},{applications, [kernel,stdlib]},"
+ "{mod, { mod, []}},{env, []}]}."),
true,
null);
try {
testBuilder(BuilderTool.REBAR);
} finally {
app.delete(true, null);
}
}
protected void removeClassFile(IPath typePath, IContainer outputFolder) throws CoreException {
if (typePath.lastSegment().indexOf('$') == -1) { // is not a nested type
this.newState.removeQualifiedTypeName(typePath.toString());
// add dependents even when the type thinks it does not exist to be on the safe side
if (JavaBuilder.DEBUG) System.out.println("Found removed type " + typePath); // $NON-NLS-1$
addDependentsOf(
typePath,
true); // when member types are removed, their enclosing type is structurally changed
}
IFile classFile =
outputFolder.getFile(typePath.addFileExtension(SuffixConstants.EXTENSION_class));
if (classFile.exists()) {
if (JavaBuilder.DEBUG)
System.out.println("Deleting class file of removed type " + typePath); // $NON-NLS-1$
classFile.delete(IResource.FORCE, null);
}
}
public static IFile getTemporaryDiagramFile(IPath dataFilePath, IFolder diagramFileTempFolder) {
final IPath path =
dataFilePath.removeFileExtension().addFileExtension(ToscaUI.TOSCA_DIAGRAM_FILE_EXTENSION);
final IFile tempFile = diagramFileTempFolder.getFile(path.lastSegment());
// We don't need anything from that file and to be sure there are no side
// effects we delete the file
if (tempFile.exists()) {
try {
tempFile.delete(true, null);
} catch (CoreException e) {
e.printStackTrace();
}
}
return tempFile;
}
protected void cleanOutput(
IBuildContext ctx, OutputConfiguration config, IProgressMonitor monitor)
throws CoreException {
final IProject project = ctx.getBuiltProject();
IFolder folder = project.getFolder(config.getOutputDirectory());
if (!folder.exists()) return;
if (config.isCanClearOutputDirectory()) {
for (IResource resource : folder.members()) resource.delete(IResource.KEEP_HISTORY, monitor);
} else {
if (config.isCleanUpDerivedResources()) {
List<IFile> resources = derivedResourceMarkers.findDerivedResources(folder, null);
for (IFile iFile : resources) {
iFile.delete(IResource.KEEP_HISTORY, monitor);
}
}
}
}
protected IStatus cleanUpDerivedResources(IProgressMonitor monitor, IProject project)
throws CoreException {
if (monitor.isCanceled()) {
return Status.CANCEL_STATUS;
}
if (shouldBeProcessed(project)) {
IContainer container = project;
if (folderNameToClean != null) container = container.getFolder(new Path(folderNameToClean));
for (IFile derivedFile : derivedResourceMarkers.findDerivedResources(container, null)) {
derivedFile.delete(true, monitor);
// deleteEmptyParent(monitor, derivedFile.getParent());
if (monitor.isCanceled()) {
return Status.CANCEL_STATUS;
}
}
}
return Status.OK_STATUS;
}
public void removeSpace(String wiki, String space) throws XWikiEclipseStorageException {
// Delete space summary file
try {
final IFolder spaceFolder = StorageUtils.createFolder(baseFolder.getFolder(SPACES_DIRECTORY));
List<IResource> spacesFolderResources = getChildResources(spaceFolder, IResource.DEPTH_ONE);
for (IResource spacesFolderResource : spacesFolderResources) {
if (spacesFolderResource instanceof IFile) {
IFile spaceFile = (IFile) spacesFolderResource;
if (spaceFile.getName().equals(getFileNameForSpaceSummary(wiki, space))) {
spaceFile.delete(true, null);
break;
}
}
}
} catch (CoreException e) {
throw new XWikiEclipseStorageException(e);
}
}
protected IFile getTestDataFile(
IProject project, String sourceName, String destPath, boolean overwrite) throws Exception {
String[] split = destPath.split("/"); // $NON-NLS-1$
IContainer parent;
String name;
if (split.length == 1) {
parent = project;
name = destPath;
} else {
IFolder folder = project.getFolder(split[0]);
NullProgressMonitor monitor = new NullProgressMonitor();
if (!folder.exists()) {
folder.create(true /* force */, true /* local */, monitor);
}
for (int i = 1, n = split.length; i < n - 1; i++) {
IFolder subFolder = folder.getFolder(split[i]);
if (!subFolder.exists()) {
subFolder.create(true /* force */, true /* local */, monitor);
}
folder = subFolder;
}
name = split[split.length - 1];
parent = folder;
}
IFile file = parent.getFile(new Path(name));
if (overwrite && file.exists()) {
String currentContents = AndmoreAndroidPlugin.readFile(file);
String newContents = readTestFile(sourceName, true);
if (currentContents == null || !currentContents.equals(newContents)) {
file.delete(true, new NullProgressMonitor());
} else {
return file;
}
}
if (!file.exists()) {
String xml = readTestFile(sourceName, true);
InputStream bstream = new ByteArrayInputStream(xml.getBytes("UTF-8")); // $NON-NLS-1$
NullProgressMonitor monitor = new NullProgressMonitor();
file.create(bstream, false /* force */, monitor);
}
return file;
}
private static IStatus removeSampleCodeAndFiles(NewLiferayPluginProjectOp op) {
IStatus status = org.eclipse.core.runtime.Status.OK_STATUS;
final boolean includeSampleCode = op.getIncludeSampleCode().content();
if (!includeSampleCode) {
final IProject project = CoreUtil.getLiferayProject(op.getFinalProjectName().content());
if (project != null && project.exists()) {
ProjectCore.operate(project, RemoveSampleElementsOperation.class);
// delete sample files: view.jsp, main.css, main.js
try {
final IWebProject webproject = LiferayCore.create(IWebProject.class, project);
if (webproject != null) {
final IFolder docroot = webproject.getDefaultDocrootFolder();
final IFile[] sampleFiles = {
docroot.getFile("view.jsp"),
docroot.getFile("css/main.css"),
docroot.getFile("js/main.js")
};
for (IFile file : sampleFiles) {
if (file != null && file.exists()) {
file.delete(true, new NullProgressMonitor());
if (file.getParent().members().length == 0) {
CoreUtil.deleteResource(file.getParent());
}
}
}
}
} catch (CoreException e) {
ProjectCore.logError("Error deleting sample files.", e);
}
}
}
return status;
}
private void saveHeader(String header) {
// TODO: use IRunnableWithProgress
IFile file = getHeaderFile();
ByteArrayInputStream stream = null;
try {
if (file.exists()) {
file.delete(true, null);
}
stream = new ByteArrayInputStream(header.getBytes()); // TODO: encoding
file.create(stream, true, null);
} catch (CoreException e) {
e.printStackTrace();
} finally {
try {
if (stream != null) stream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/** Tests creating a linked file under a virtual folder */
public void testCreateLinkedFileUnderVirtualFolder() {
// get a non-existing location
IPath location = getRandomLocation();
IFile file = existingVirtualFolderInExistingProject.getFile(getUniqueString());
try {
file.createLink(location, IResource.ALLOW_MISSING_LOCAL, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
assertTrue("2.0", file.exists());
assertEquals("3.0", location, file.getLocation());
assertTrue("4.0", !location.toFile().exists());
// delete should succeed
try {
file.delete(IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("5.0", e);
}
}
private void clean(List<FileDelta> fileDeltas, IProgressMonitor monitor) throws CoreException {
// clear the problem markers
this.getProject().deleteMarkers(MARKER_TYPE, true, IResource.DEPTH_INFINITE);
// remove the built files if compile-on-save is enabled
IPreferenceStore preferenceStore = TypeScriptPlugin.getDefault().getPreferenceStore();
if (preferenceStore.getBoolean(IPreferenceConstants.COMPILER_COMPILE_ON_SAVE)) {
for (FileDelta fileDelta : fileDeltas) {
String fileName = fileDelta.getFileName();
ImmutableList<String> builtFiles = getBuiltFiles(fileName);
for (String builtFile : builtFiles) {
Path path = new Path(builtFile);
IFile file = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(path);
file.refreshLocal(IResource.DEPTH_ZERO, monitor);
if (file.exists()) {
file.delete(false, monitor);
}
}
}
}
}
