public void testMovePackage2() throws JavaModelException { IPath projectPath = env.addProject("Project"); // $NON-NLS-1$ env.addExternalJars(projectPath, Util.getJavaClassLibs()); env.removePackageFragmentRoot(projectPath, ""); // $NON-NLS-1$ IPath src = env.addPackageFragmentRoot(projectPath, "src"); // $NON-NLS-1$ IPath other = env.addFolder(projectPath, "other"); // $NON-NLS-1$ env.setOutputFolder(projectPath, "bin"); // $NON-NLS-1$ IPath classA = env.addClass( src, "p", "A", //$NON-NLS-1$ //$NON-NLS-2$ "package p; \n" + //$NON-NLS-1$ "public class A extends Missing {}"); //$NON-NLS-1$ IPath classB = env.addClass( src, "p.q", "B", //$NON-NLS-1$ //$NON-NLS-2$ "package p.q; \n" + //$NON-NLS-1$ "public class B extends Missing {}"); //$NON-NLS-1$ fullBuild(projectPath); expectingSpecificProblemFor( classA, new Problem( "", "Missing cannot be resolved to a type", new Path("/Project/src/p/A.java"), 35, 42, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR) // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ ); expectingSpecificProblemFor( classB, new Problem( "", "Missing cannot be resolved to a type", new Path("/Project/src/p/q/B.java"), 37, 44, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR) // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ ); try { IProject p = env.getProject(projectPath); IFolder pFolder = p.getWorkspace().getRoot().getFolder(classA.removeLastSegments(1)); pFolder.move(other.append("p"), true, false, null); } catch (CoreException e) { env.handle(e); } incrementalBuild(projectPath); expectingNoProblems(); }
@Override protected IStatus run(IProgressMonitor monitor) { IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects(); monitor.beginTask("Refreshing git managed projects", projects.length); while (projectsToScan.size() > 0) { IProject p; synchronized (projectsToScan) { if (projectsToScan.size() == 0) break; Iterator<IProject> i = projectsToScan.iterator(); p = i.next(); i.remove(); } ISchedulingRule rule = p.getWorkspace().getRuleFactory().refreshRule(p); try { getJobManager().beginRule(rule, monitor); p.refreshLocal(IResource.DEPTH_INFINITE, new SubProgressMonitor(monitor, 1)); } catch (CoreException e) { logError("Failed to refresh projects from index changes", e); return new Status(IStatus.ERROR, getPluginId(), e.getMessage()); } finally { getJobManager().endRule(rule); } } monitor.done(); return Status.OK_STATUS; }
protected void checkIfPathValid() { fFolder = null; IContainer folder = null; if (fUseFolderButton.isSelected()) { String pathStr = fContainerDialogField.getText(); if (pathStr.length() == 0) { fContainerFieldStatus.setError(NewWizardMessages.NewSourceFolderDialog_error_enterpath); return; } IPath path = fCurrProject.getFullPath().append(pathStr); IWorkspace workspace = fCurrProject.getWorkspace(); IStatus pathValidation = workspace.validatePath(path.toString(), IResource.FOLDER); if (!pathValidation.isOK()) { fContainerFieldStatus.setError( Messages.format( NewWizardMessages.NewSourceFolderDialog_error_invalidpath, pathValidation.getMessage())); return; } folder = fCurrProject.getFolder(pathStr); } else { folder = fCurrProject; } if (isExisting(folder)) { fContainerFieldStatus.setError(NewWizardMessages.NewSourceFolderDialog_error_pathexists); return; } fContainerFieldStatus.setOK(); fFolder = folder; }
private void createExternalSourceArchivesProject(IProject project, IProgressMonitor monitor) throws CoreException { IProjectDescription desc = project.getWorkspace().newProjectDescription(project.getName()); IPath stateLocation = CeylonPlugin.getInstance().getStateLocation(); desc.setLocation(stateLocation.append(EXTERNAL_PROJECT_NAME)); project.create(desc, IResource.HIDDEN, monitor); }
private IProject createProject(final GridProjectProperties props, final IProgressMonitor monitor) throws CoreException { monitor.subTask(Messages.getString("GridProjectCreationOperation.init_task")); // $NON-NLS-1$ String projectName = props.getProjectName(); IPath projectPath = props.getProjectLocation(); IProject[] referencesProjects = props.getReferencesProjects(); IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); IProject project = workspaceRoot.getProject(projectName); IStatus status = ResourcesPlugin.getWorkspace().validateProjectLocation(project, projectPath); if (status.getSeverity() != IStatus.OK) { throw new CoreException(status); } IProjectDescription desc = project.getWorkspace().newProjectDescription(projectName); desc.setLocation(projectPath); if (referencesProjects != null) { desc.setReferencedProjects(referencesProjects); } project.create(desc, new SubProgressMonitor(monitor, 50)); project.open(new SubProgressMonitor(monitor, 50)); createProjectStructure(project, props); setProjectProperties(project, props); if (monitor.isCanceled()) { throw new OperationCanceledException(); } return project; }
public static List<IProject> decodeUsedProjects(String usedProjects, IProject project) { if (usedProjects == null || usedProjects.length() == 0) { return new ArrayList<IProject>(); } String[] paths = usedProjects.split(";"); List<IProject> l = new ArrayList<IProject>(paths.length); for (int i = 0; i < paths.length; i++) { l.add(project.getWorkspace().getRoot().getProject(paths[i])); } return l; }
@Override public IStatus runInWorkspace(IProgressMonitor monitor) { Set<Repository> repos; synchronized (repositoriesChanged) { if (repositoriesChanged.isEmpty()) { return Status.OK_STATUS; } repos = new LinkedHashSet<>(repositoriesChanged); repositoriesChanged.clear(); } IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects(); Set<IProject> toRefresh = new LinkedHashSet<>(); for (IProject p : projects) { if (!p.isAccessible()) { continue; } RepositoryMapping mapping = RepositoryMapping.getMapping(p); if (mapping != null && repos.contains(mapping.getRepository())) { toRefresh.add(p); } } monitor.beginTask(UIText.Activator_refreshingProjects, toRefresh.size()); for (IProject p : toRefresh) { if (monitor.isCanceled()) { return Status.CANCEL_STATUS; } ISchedulingRule rule = p.getWorkspace().getRuleFactory().refreshRule(p); try { getJobManager().beginRule(rule, monitor); // handle missing projects after branch switch if (p.isAccessible()) { p.refreshLocal(IResource.DEPTH_INFINITE, new SubProgressMonitor(monitor, 1)); } } catch (CoreException e) { handleError(UIText.Activator_refreshFailed, e, false); return new Status(IStatus.ERROR, getPluginId(), e.getMessage()); } finally { getJobManager().endRule(rule); } } if (!monitor.isCanceled()) { // re-schedule if we got some changes in the meantime synchronized (repositoriesChanged) { if (!repositoriesChanged.isEmpty()) { schedule(100); } } } monitor.done(); return Status.OK_STATUS; }
public SetFilterWizardPage(BPListElement entryToEdit, ArrayList existingEntries) { super(PAGE_NAME); fExistingEntries = existingEntries; setTitle(NewWizardMessages.ExclusionInclusionDialog_title); setDescription(NewWizardMessages.ExclusionInclusionDialog_description2); fCurrElement = entryToEdit; fCurrProject = entryToEdit.getScriptProject().getProject(); IWorkspaceRoot root = fCurrProject.getWorkspace().getRoot(); IResource res = root.findMember(entryToEdit.getPath()); if (res instanceof IContainer) { fCurrSourceFolder = (IContainer) res; } String excLabel = NewWizardMessages.ExclusionInclusionDialog_exclusion_pattern_label; ImageDescriptor excDescriptor = DLTKPluginImages.DESC_OBJS_EXCLUSION_FILTER_ATTRIB; String[] excButtonLabels = new String[] { NewWizardMessages.ExclusionInclusionDialog_exclusion_pattern_add, NewWizardMessages.ExclusionInclusionDialog_exclusion_pattern_add_multiple, NewWizardMessages.ExclusionInclusionDialog_exclusion_pattern_edit, null, NewWizardMessages.ExclusionInclusionDialog_exclusion_pattern_remove }; String incLabel = NewWizardMessages.ExclusionInclusionDialog_inclusion_pattern_label; ImageDescriptor incDescriptor = DLTKPluginImages.DESC_OBJS_INCLUSION_FILTER_ATTRIB; String[] incButtonLabels = new String[] { NewWizardMessages.ExclusionInclusionDialog_inclusion_pattern_add, NewWizardMessages.ExclusionInclusionDialog_inclusion_pattern_add_multiple, NewWizardMessages.ExclusionInclusionDialog_inclusion_pattern_edit, null, NewWizardMessages.ExclusionInclusionDialog_inclusion_pattern_remove }; fExclusionPatternList = createListContents( entryToEdit, BPListElement.EXCLUSION, excLabel, excDescriptor, excButtonLabels); fInclusionPatternList = createListContents( entryToEdit, BPListElement.INCLUSION, incLabel, incDescriptor, incButtonLabels); }
/** * Moves all files currently located in the temporary files folder into the build directory * * @param monitor progress monitor * @throws CoreException if an error occurs */ private void restoreTempFiles(IProgressMonitor monitor) throws CoreException { final Set<IPath> tempNames = tracking.getTempFiles(); if (tempDir == null || tempNames.isEmpty()) { movedFiles = new HashSet<IPath>(); return; } // Move files and store new paths for later reversal project .getWorkspace() .run( new IWorkspaceRunnable() { public void run(IProgressMonitor monitor) throws CoreException { movedFiles = moveFiles(tempDir, sourceDir, tracking.getTempFiles(), false, false, monitor); } }, monitor); }
/** * Determine the exposed (exported) dependencies from the project named 'otherProject' and add * them to the accumulatedPathEntries String Set. This will include the output location of the * project plus other kinds of entry that are re-exported. If dependent on another project and * that project is re-exported, the method will recurse. * * @param baseProject the original project for which the classpath is being computed * @param otherProject a project something in the dependency chain for the original project * @param accumulatedPathEntries a String set of classpath entries, into which new entries should * be added */ private static void computeDependenciesFromProject( IProject baseProject, String otherProject, Set accumulatedPathEntries) throws JavaModelException { // First the output location for the project: IProject iproject = baseProject.getWorkspace().getRoot().getProject(otherProject); IJavaProject ijp = JavaCore.create(iproject); accumulatedPathEntries.add(pathToString(ijp.getOutputLocation(), iproject)); // Look for exported entries from otherProject IClasspathEntry[] cpes = ijp.getResolvedClasspath(true); if (cpes != null) { for (int j = 0; j < cpes.length; j++) { IClasspathEntry cpe = cpes[j]; if (cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE) { continue; } if (cpe.isExported()) { // TODO should quickly dismiss source entries? others? IPath cpePath = cpes[j].getPath(); String segmentZero = cpePath.segment(0); if (segmentZero != null && segmentZero.equals(otherProject)) { accumulatedPathEntries.add( iproject.getFile(cpePath.removeFirstSegments(1)).getRawLocation().toOSString()); } else { if (cpe.getEntryKind() == IClasspathEntry.CPE_PROJECT) { // segmentZero is a project name computeDependenciesFromProject(baseProject, segmentZero, accumulatedPathEntries); } else { String otherPathElement = null; if (segmentZero != null && segmentZero.equals(iproject.getName())) { otherPathElement = iproject.getFile(cpePath.removeFirstSegments(1)).getRawLocation().toOSString(); } else { otherPathElement = cpePath.toOSString(); } accumulatedPathEntries.add(otherPathElement); } } } } } }
@Override protected IStatus run(IProgressMonitor monitor) { try { // A repository can contain many projects, only scan once // (a project could in theory be distributed among many // repositories. We discard that as being ugly and stupid for // the moment. IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects(); monitor.beginTask("Scanning Git repositories for changes", projects.length); Set<Repository> scanned = new HashSet<Repository>(); for (IProject p : projects) { RepositoryMapping mapping = RepositoryMapping.getMapping(p); if (mapping != null) { Repository r = mapping.getRepository(); if (!scanned.contains(r)) { if (monitor.isCanceled()) break; trace("Scanning " + r + " for changes"); scanned.add(r); ISchedulingRule rule = p.getWorkspace().getRuleFactory().modifyRule(p); getJobManager().beginRule(rule, monitor); try { r.scanForRepoChanges(); } finally { getJobManager().endRule(rule); } } } monitor.worked(1); } monitor.done(); trace("Rescheduling " + getName() + " job"); schedule(REPO_SCAN_INTERVAL); } catch (Exception e) { trace("Stopped rescheduling " + getName() + "job"); return new Status( IStatus.ERROR, getPluginId(), 0, "An error occurred while scanning for changes. Scanning aborted", e); } return Status.OK_STATUS; }
/** * Moves temporary files out of the build directory, if applicable. A file is considered a * temporary file, if * * <ul> * <li>it had been in the temporary files folder before the build process * <p><b>or</b> * <li>it was created or modified during the build process, and has a temporary file extension * as specified in the preferences * </ul> * * @param excludes set of paths to exclude from moving, e.g. because they are the main output * files * @param monitor progress monitor * @throws CoreException if an error occurs */ private void moveTempFiles(final Set<IPath> excludes, IProgressMonitor monitor) throws CoreException { final IContainer aSourceContainer = getActualSourceContainer(); if (tracking.isInitial() || aSourceContainer == null || !aSourceContainer.exists()) { return; } final boolean markAsDerived = "true" .equals( TexlipseProperties.getProjectProperty( project, TexlipseProperties.MARK_TEMP_DERIVED_PROPERTY)); final String[] tempExts = TexlipsePlugin.getPreferenceArray(TexlipseProperties.TEMP_FILE_EXTS); // Check if there is anything to do if (markAsDerived || tempDir != null) { // First move temporary files, which had been placed into the source folder // just prior to the build; // then check for new temporary files, which need to be moved project .getWorkspace() .run( new IWorkspaceRunnable() { public void run(IProgressMonitor monitor) throws CoreException { if (movedFiles != null) { if (excludes != null) { movedFiles.removeAll(excludes); } moveFiles(sourceDir, tempDir, movedFiles, markAsDerived, true, monitor); } final Set<IPath> newTempNames = tracking.getNewTempNames(aSourceContainer, tempExts, format, monitor); if (excludes != null) { newTempNames.removeAll(excludes); } moveFiles(sourceDir, tempDir, newTempNames, markAsDerived, true, monitor); } }, monitor); } }
/** * Create a new java project * * @param projectName a project name * @return newProject a new project resource handle */ public static IProject createJavaProject(final String projectName) throws CoreException { // 1. Get the project from the workspace final IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); final IProject newProject = root.getProject(projectName); final IProjectDescription description = newProject.getWorkspace().newProjectDescription(projectName); // 2. Create a project if it does not already exist if (!newProject.exists()) { description.setLocation(null); newProject.create(description, null); } if (!newProject.isOpen()) { newProject.open(null); } // 4. Make it a Java Project addJavaNature(newProject); return newProject; }
/** * Creates the Acceleo project. * * @param monitor The progress monitor. */ private void createProject(IProgressMonitor monitor) { try { IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(newProjectPage.getProjectName()); IPath location = newProjectPage.getLocationPath(); if (!project.exists()) { IProjectDescription desc = project.getWorkspace().newProjectDescription(newProjectPage.getProjectName()); if (ResourcesPlugin.getWorkspace().getRoot().getLocation().equals(location)) { location = null; } desc.setLocation(location); project.create(desc, monitor); project.open(monitor); boolean shouldGenerateModules = !(getContainer().getCurrentPage() instanceof WizardNewProjectCreationPage); convert( project, newProjectPage.getSelectedJVM(), newAcceleoModulesCreationPage.getAllModules(), shouldGenerateModules, monitor); IWorkingSet[] workingSets = newProjectPage.getSelectedWorkingSets(); getWorkbench().getWorkingSetManager().addToWorkingSets(project, workingSets); project.build( IncrementalProjectBuilder.FULL_BUILD, AcceleoBuilder.BUILDER_ID, new HashMap<String, String>(), monitor); } } catch (CoreException e) { AcceleoUIActivator.log(e, true); } }
/** * Renames output files and/or moves them if necessary. A file is considered an output file, if * * <ul> * <li>it is the current output file (which can also be from a temporary build) * <p><b>or</b> * <li>it has the same file name as the current input file, apart from its file extension, and * one of the derived file extensions as specified in the preferences * </ul> * * @param monitor progress monitor * @return set of paths to the (possibly moved) files * @throws CoreException if an error occurs */ private Set<IPath> moveOutputFiles(IProgressMonitor monitor) throws CoreException { final boolean markAsDerived = "true" .equals( TexlipseProperties.getProjectProperty( project, TexlipseProperties.MARK_OUTPUT_DERIVED_PROPERTY)); final String[] derivedExts = TexlipsePlugin.getPreferenceArray(TexlipseProperties.DERIVED_FILES); final IFile aSourceFile = getActualSourceFile(); final IContainer aSourceContainer = getActualSourceContainer(); final IFile sOutputFile = getSelectedOutputFile(); final IContainer sOutputContainer = getSelectedOutputContainer(markAsDerived, monitor); if (aSourceFile == null || aSourceContainer == null || sOutputFile == null || sOutputContainer == null) { // Something is wrong with the settings return null; } // Get name without extension from main files for renaming final String dotFormat = '.' + format; final String sourceBaseName = stripFileExt(aSourceFile.getName(), null); final String outputBaseName = stripFileExt(sOutputFile.getName(), dotFormat); // Check if files are to be moved or renamed final boolean moveFiles = !sourceBaseName.equals(outputBaseName) || !sOutputContainer.equals(aSourceContainer); // Retrieve output and other derived files along with their extensions final Map<IPath, String> outputFiles = ProjectFileTracking.getOutputNames( aSourceContainer, sourceBaseName, derivedExts, format, monitor); // Check if there is anything to do if ((moveFiles || markAsDerived) && !outputFiles.isEmpty()) { final Set<IPath> movedFiles = new HashSet<IPath>(outputFiles.size()); project .getWorkspace() .run( new IWorkspaceRunnable() { public void run(IProgressMonitor monitor) throws CoreException { // Move files to destination folder and rename for (Entry<IPath, String> entry : outputFiles.entrySet()) { IFile currentFile = project.getFile(entry.getKey()); if (moveFiles) { // Determine new file name String destName = outputBaseName + entry.getValue(); // Move file IFile dest = moveFile(project, currentFile, sOutputContainer, destName, monitor); if (dest != null && markAsDerived) { dest.setDerived(true); } movedFiles.add(dest.getProjectRelativePath()); } else { // Possibly mark as derived if (markAsDerived) { currentFile.setDerived(true); } movedFiles.add(entry.getKey()); } } } }, monitor); return movedFiles; } else { return outputFiles.keySet(); } }
/* * Update projects references so that the build order is consistent with the classpath */ public void updateProjectReferencesIfNecessary() throws JavaModelException { String[] oldRequired = this.oldResolvedClasspath == null ? CharOperation.NO_STRINGS : this.project.projectPrerequisites(this.oldResolvedClasspath); IClasspathEntry[] newResolvedClasspath = this.project.getResolvedClasspath(); String[] newRequired = this.project.projectPrerequisites(newResolvedClasspath); final IProject projectResource = this.project.getProject(); try { IProject[] projectReferences = projectResource.getDescription().getDynamicReferences(); HashSet oldReferences = new HashSet(projectReferences.length); for (int i = 0; i < projectReferences.length; i++) { String projectName = projectReferences[i].getName(); oldReferences.add(projectName); } HashSet newReferences = (HashSet) oldReferences.clone(); for (int i = 0; i < oldRequired.length; i++) { String projectName = oldRequired[i]; newReferences.remove(projectName); } for (int i = 0; i < newRequired.length; i++) { String projectName = newRequired[i]; newReferences.add(projectName); } Iterator iter; int newSize = newReferences.size(); checkIdentity: { if (oldReferences.size() == newSize) { iter = newReferences.iterator(); while (iter.hasNext()) { if (!oldReferences.contains(iter.next())) { break checkIdentity; } } return; } } String[] requiredProjectNames = new String[newSize]; int index = 0; iter = newReferences.iterator(); while (iter.hasNext()) { requiredProjectNames[index++] = (String) iter.next(); } Util.sort(requiredProjectNames); // ensure that if changed, the order is consistent final IProject[] requiredProjectArray = new IProject[newSize]; IWorkspaceRoot wksRoot = projectResource.getWorkspace().getRoot(); for (int i = 0; i < newSize; i++) { requiredProjectArray[i] = wksRoot.getProject(requiredProjectNames[i]); } // ensure that a scheduling rule is used so that the project description is not modified by // another thread while we update it // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=214981 // also ensure that if no change (checkIdentify block returned above) we don't reach here // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=241751 IWorkspace workspace = projectResource.getWorkspace(); ISchedulingRule rule = workspace .getRuleFactory() .modifyRule(projectResource); // scheduling rule for modifying the project IWorkspaceRunnable runnable = new IWorkspaceRunnable() { public void run(IProgressMonitor monitor) throws CoreException { IProjectDescription description = projectResource.getDescription(); description.setDynamicReferences(requiredProjectArray); projectResource.setDescription(description, IResource.AVOID_NATURE_CONFIG, null); } }; workspace.run(runnable, rule, IWorkspace.AVOID_UPDATE, null); } catch (CoreException e) { if (!ExternalJavaProject.EXTERNAL_PROJECT_NAME.equals(this.project.getElementName())) throw new JavaModelException(e); } }
private IProject createExternalFoldersProject(IProgressMonitor monitor) { IProject project = getExternalFoldersProject(); if (!project.isAccessible()) { try { if (!project.exists()) { IProjectDescription desc = project.getWorkspace().newProjectDescription(project.getName()); IPath stateLocation = DLTKCore.getPlugin().getStateLocation(); desc.setLocation(stateLocation.append(EXTERNAL_PROJECT_NAME)); project.create(desc, IResource.HIDDEN, monitor); } try { project.open(monitor); } catch (CoreException e1) { // .project or folder on disk have been deleted, recreate // them IPath stateLocation = DLTKCore.getPlugin().getStateLocation(); IPath projectPath = stateLocation.append(EXTERNAL_PROJECT_NAME); projectPath.toFile().mkdirs(); FileOutputStream output = new FileOutputStream( projectPath.append(IScriptProjectFilenames.PROJECT_FILENAME).toOSString()); try { output.write( ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + //$NON-NLS-1$ "<projectDescription>\n" //$NON-NLS-1$ + " <name>" //$NON-NLS-1$ + EXTERNAL_PROJECT_NAME + "</name>\n" + //$NON-NLS-1$ " <comment></comment>\n" + //$NON-NLS-1$ " <projects>\n" + //$NON-NLS-1$ " </projects>\n" + //$NON-NLS-1$ " <buildSpec>\n" + //$NON-NLS-1$ " </buildSpec>\n" + //$NON-NLS-1$ " <natures>\n" + //$NON-NLS-1$ " </natures>\n" + //$NON-NLS-1$ "</projectDescription>") .getBytes()); //$NON-NLS-1$ } finally { output.close(); } project.open(null); } } catch (CoreException e) { Util.log(e, "Problem creating hidden project for external folders"); // $NON-NLS-1$ return project; } catch (IOException e) { Util.log(e, "Problem creating hidden project for external folders"); // $NON-NLS-1$ return project; } } return project; }
private String getWorkspacePath() { return project.getWorkspace().getRoot().getLocation().toOSString(); }
// public for testing public static String calculateClasspath(IJavaProject javaProject) { try { Set accumulatedPathEntries = new LinkedHashSet(); IProject project = javaProject.getProject(); String projectName = project.getName(); IPath defaultOutputPath = javaProject.getOutputLocation(); String defaultOutputLocation = pathToString(defaultOutputPath, project); IClasspathEntry[] cpes = javaProject.getResolvedClasspath(true); if (cpes != null) { for (int i = 0, max = cpes.length; i < max; i++) { IClasspathEntry cpe = cpes[i]; if (cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE) { continue; } // Two kinds of entry we are interested in - those relative and those absolute // relative example: grails/lib/hibernate3-3.3.1.jar (where grails is the project name) // absolute example: f:/grails-111/dist/grails-core-blah.jar // javaProject path is f:\grails\grails IPath cpePath = cpe.getPath(); String pathElement = null; String segmentZero = cpePath.segment(0); if (segmentZero.equals(projectName)) { pathElement = project.getFile(cpePath.removeFirstSegments(1)).getRawLocation().toOSString(); } else { // for GRECLIPSE-917. Entry is something like /SomeOtherProject/foo/bar/doodah.jar if (cpe.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { try { IProject iproject = project.getWorkspace().getRoot().getProject(segmentZero); if (iproject != null) { IFile ifile = iproject.getFile(cpePath.removeFirstSegments(1)); IPath ipath = (ifile == null ? null : ifile.getRawLocation()); pathElement = (ipath == null ? null : ipath.toOSString()); } } catch (Throwable t) { t.printStackTrace(); } } if (cpe.getEntryKind() == IClasspathEntry.CPE_PROJECT) { // the classpath entry is a dependency on another project computeDependenciesFromProject(project, segmentZero, accumulatedPathEntries); // FIXASC this ought to also allow for separate output folders in the project we // depend upon *sigh* // FIXASC what does all this look like for batch compilation? Should it be passed in // rather than computed here } else { if (pathElement == null) { pathElement = cpe.getPath().toOSString(); } } } if (pathElement != null) { accumulatedPathEntries.add(pathElement); } } accumulatedPathEntries.add(defaultOutputLocation); StringBuilder sb = new StringBuilder(); Iterator iter = accumulatedPathEntries.iterator(); while (iter.hasNext()) { sb.append((String) iter.next()); sb.append(File.pathSeparator); } String classpath = sb.toString(); // System.out.println("Project classpath for '"+projectName+"' is "+classpath); return classpath; } } catch (JavaModelException jme) { System.err.println( "Problem trying to determine classpath of project " + javaProject.getProject().getName() + ":"); //$NON-NLS-1$ //$NON-NLS-2$ jme.printStackTrace(); } return ""; //$NON-NLS-1$ }
private IWorkspaceRoot getWorkspaceRoot(final IJavaProject javaProject) { IProject _project = javaProject.getProject(); IWorkspace _workspace = _project.getWorkspace(); return _workspace.getRoot(); }