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); } } } } }