Java tutorial
/** * Copyright (C) 2005 - 2014 Eric Van Dewoestine * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.eclim.plugin.jdt.project; import java.io.File; import java.io.FileInputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.lang.StringUtils; import org.eclim.Services; import org.eclim.command.CommandLine; import org.eclim.command.Error; import org.eclim.command.Options; import org.eclim.plugin.core.project.ProjectManager; import org.eclim.plugin.core.util.ProjectUtils; import org.eclim.plugin.core.util.XmlUtils; import org.eclim.plugin.jdt.PluginResources; import org.eclim.plugin.jdt.project.classpath.Dependency; import org.eclim.plugin.jdt.project.classpath.IvyParser; import org.eclim.plugin.jdt.project.classpath.MvnParser; import org.eclim.plugin.jdt.project.classpath.Parser; import org.eclim.plugin.jdt.util.JavaUtils; import org.eclim.util.IOUtils; import org.eclim.util.file.FileOffsets; import org.eclim.util.file.FileUtils; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IProjectDescription; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.jdt.core.IClasspathAttribute; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.IJavaModelStatus; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.JavaConventions; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.internal.core.JavaProject; import org.eclipse.jdt.internal.ui.wizards.ClassPathDetector; import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock; import org.eclipse.jdt.internal.ui.wizards.buildpaths.CPListElement; import org.eclipse.jdt.ui.PreferenceConstants; import org.eclipse.jface.preference.IPreferenceStore; /** * Implementation of {@link ProjectManager} for java projects. * * @author Eric Van Dewoestine */ public class JavaProjectManager implements ProjectManager { private static final String PRESERVE = "eclim.preserve"; private static final String CLASSPATH = ".classpath"; private static final String CLASSPATH_XSD = "/resources/schema/eclipse/classpath.xsd"; private static final HashMap<String, Parser> PARSERS = new HashMap<String, Parser>(); static { PARSERS.put("ivy.xml", new IvyParser()); PARSERS.put("pom.xml", new MvnParser()); } @Override public void create(IProject project, CommandLine commandLine) throws Exception { String depends = commandLine.getValue(Options.DEPENDS_OPTION); create(project, depends); } @Override public List<Error> update(IProject project, CommandLine commandLine) throws Exception { String buildfile = commandLine.getValue(Options.BUILD_FILE_OPTION); IJavaProject javaProject = JavaUtils.getJavaProject(project); javaProject.getResource().refreshLocal(IResource.DEPTH_INFINITE, null); // validate that .classpath xml is well formed and valid. PluginResources resources = (PluginResources) Services.getPluginResources(PluginResources.NAME); List<Error> errors = XmlUtils.validateXml(javaProject.getProject().getName(), CLASSPATH, resources.getResource(CLASSPATH_XSD).toString()); if (errors.size() > 0) { return errors; } String dotclasspath = javaProject.getProject().getFile(CLASSPATH).getRawLocation().toOSString(); // ivy.xml, pom.xml, etc updated. if (buildfile != null) { try { IClasspathEntry[] entries = mergeWithBuildfile(javaProject, buildfile); errors = setClasspath(javaProject, entries, dotclasspath); } catch (IllegalStateException ise) { errors.add(new Error(ise.getMessage(), buildfile, 1, 1, false)); } // .classpath updated. } else { // if an exception occurs reading the classpath then eclipse will return a // default classpath which we would otherwise then write back into the // .classpath file. This hack prevents that and will return a relevent // error message as a validation error. try { ((JavaProject) javaProject).readFileEntriesWithException(null); } catch (Exception e) { errors.add(new Error(e.getMessage(), dotclasspath, 1, 1, false)); return errors; } IClasspathEntry[] entries = javaProject.readRawClasspath(); errors = setClasspath(javaProject, entries, dotclasspath); } if (errors.size() > 0) { return errors; } return null; } @Override public void refresh(IProject project, CommandLine commandLine) throws Exception { } @Override public void refresh(IProject project, IFile file) throws Exception { } @Override public void delete(IProject project, CommandLine commandLine) throws Exception { } // Project creation methods /** * Creates a new project. * * @param project The project. * @param depends Comma separated project names this project depends on. */ protected void create(IProject project, String depends) throws Exception { // with scala-ide installed, apparently this needs to be explicitly done IProjectDescription desc = project.getDescription(); if (!desc.hasNature(PluginResources.NATURE)) { String[] natures = desc.getNatureIds(); String[] newNatures = new String[natures.length + 1]; System.arraycopy(natures, 0, newNatures, 0, natures.length); newNatures[natures.length] = PluginResources.NATURE; desc.setNatureIds(newNatures); project.setDescription(desc, new NullProgressMonitor()); } IJavaProject javaProject = JavaCore.create(project); ((JavaProject) javaProject).configure(); if (!project.getFile(CLASSPATH).exists()) { ArrayList<IClasspathEntry> classpath = new ArrayList<IClasspathEntry>(); boolean source = false; boolean container = false; ClassPathDetector detector = new ClassPathDetector(project, null); for (IClasspathEntry entry : detector.getClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { source = true; } else if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) { container = true; } classpath.add(entry); } // default source folder if (!source) { IResource src; IPreferenceStore store = PreferenceConstants.getPreferenceStore(); String name = store.getString(PreferenceConstants.SRCBIN_SRCNAME); boolean srcBinFolders = store.getBoolean(PreferenceConstants.SRCBIN_FOLDERS_IN_NEWPROJ); if (srcBinFolders && name.length() > 0) { src = javaProject.getProject().getFolder(name); } else { src = javaProject.getProject(); } classpath.add(new CPListElement(javaProject, IClasspathEntry.CPE_SOURCE, src.getFullPath(), src) .getClasspathEntry()); File srcPath = new File(ProjectUtils.getFilePath(project, src.getFullPath().toString())); if (!srcPath.exists()) { srcPath.mkdirs(); } } // default containers if (!container) { for (IClasspathEntry entry : PreferenceConstants.getDefaultJRELibrary()) { classpath.add(entry); } } // dependencies on other projects for (IClasspathEntry entry : createOrUpdateDependencies(javaProject, depends)) { classpath.add(entry); } javaProject.setRawClasspath(classpath.toArray(new IClasspathEntry[classpath.size()]), null); // output location IPath output = detector.getOutputLocation(); if (output == null) { output = BuildPathsBlock.getDefaultOutputLocation(javaProject); } javaProject.setOutputLocation(output, null); } javaProject.makeConsistent(null); javaProject.save(null, false); } /** * Creates or updates the projects dependencies on other projects. * * @param project The project. * @param depends The comma seperated list of project names. */ protected IClasspathEntry[] createOrUpdateDependencies(IJavaProject project, String depends) throws Exception { if (depends != null) { String[] dependPaths = StringUtils.split(depends, ','); IClasspathEntry[] entries = new IClasspathEntry[dependPaths.length]; for (int ii = 0; ii < dependPaths.length; ii++) { IProject theProject = ProjectUtils.getProject(dependPaths[ii]); if (!theProject.exists()) { throw new IllegalArgumentException( Services.getMessage("project.depends.not.found", dependPaths[ii])); } IJavaProject otherProject = JavaCore.create(theProject); entries[ii] = JavaCore.newProjectEntry(otherProject.getPath(), true); } return entries; } return new IClasspathEntry[0]; } /** * Merges the supplied classpath entries into one. * * @param entries The array of classpath entry arrays to merge. * * @return The union of all entry arrays. */ protected IClasspathEntry[] merge(IClasspathEntry[][] entries) { ArrayList<IClasspathEntry> union = new ArrayList<IClasspathEntry>(); if (entries != null) { for (IClasspathEntry[] values : entries) { if (values != null) { for (IClasspathEntry entry : values) { if (!union.contains(entry)) { union.add(entry); } } } } } return (IClasspathEntry[]) union.toArray(new IClasspathEntry[union.size()]); } // Project update methods /** * Sets the classpath for the supplied project. * * @param javaProject The project. * @param entries The classpath entries. * @param classpath The file path of the .classpath file. * @return Array of Error or null if no errors reported. */ protected List<Error> setClasspath(IJavaProject javaProject, IClasspathEntry[] entries, String classpath) throws Exception { FileOffsets offsets = FileOffsets.compile(classpath); String classpathValue = IOUtils.toString(new FileInputStream(classpath)); ArrayList<Error> errors = new ArrayList<Error>(); for (IClasspathEntry entry : entries) { IJavaModelStatus status = JavaConventions.validateClasspathEntry(javaProject, entry, true); if (!status.isOK()) { errors.add(createErrorForEntry(javaProject, entry, status, offsets, classpath, classpathValue)); } } IJavaModelStatus status = JavaConventions.validateClasspath(javaProject, entries, javaProject.getOutputLocation()); // always set the classpathValue anyways, so that the user can correct the // file. //if(status.isOK() && errors.isEmpty()){ javaProject.setRawClasspath(entries, null); javaProject.makeConsistent(null); //} if (!status.isOK()) { errors.add(new Error(status.getMessage(), classpath, 1, 1, false)); } return errors; } /** * Creates an Error from the supplied IJavaModelStatus. * * @param project The java project. * @param entry The classpath entry. * @param status The IJavaModelStatus. * @param offsets File offsets for the classpath file. * @param filename The filename of the error. * @param contents The contents of the file as a String. * @return The Error. */ protected Error createErrorForEntry(IJavaProject project, IClasspathEntry entry, IJavaModelStatus status, FileOffsets offsets, String filename, String contents) throws Exception { int line = 0; int col = 0; String path = entry.getPath().toOSString(); path = path.replaceFirst("^/" + project.getProject().getName() + "/", ""); Matcher matcher = Pattern.compile("path\\s*=(['\"])\\s*\\Q" + path + "\\E\\s*\\1").matcher(contents); if (matcher.find()) { int[] position = offsets.offsetToLineColumn(matcher.start()); line = position[0]; col = position[1]; } return new Error(status.getMessage(), filename, line, col, false); } /** * Merge the supplied project's classpath with entries found in the specified * build file. * * @param project The project. * @param buildfile The path to the build file (pom.xml, ivy.xml, etc) * @return The classpath entries. */ protected IClasspathEntry[] mergeWithBuildfile(IJavaProject project, String buildfile) throws Exception { String filename = FileUtils.getBaseName(buildfile); Parser parser = PARSERS.get(filename); String var = parser.getClasspathVar(); Dependency[] dependencies = parser.parse(buildfile); IWorkspaceRoot root = project.getProject().getWorkspace().getRoot(); ArrayList<IClasspathEntry> results = new ArrayList<IClasspathEntry>(); // load the results with all the non library entries. IClasspathEntry[] entries = project.getRawClasspath(); for (IClasspathEntry entry : entries) { if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY && entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE) { results.add(entry); } else { IPath path = entry.getPath(); String prefix = path != null ? path.segment(0) : null; if ((!var.equals(prefix)) || preserve(entry)) { results.add(entry); } } } // merge the dependencies with the classpath entires. for (int ii = 0; ii < dependencies.length; ii++) { IClasspathEntry match = null; for (int jj = 0; jj < entries.length; jj++) { if (entries[jj].getEntryKind() == IClasspathEntry.CPE_LIBRARY || entries[jj].getEntryKind() == IClasspathEntry.CPE_VARIABLE) { String path = entries[jj].getPath().toOSString(); String pattern = dependencies[ii].getName() + Dependency.VERSION_SEPARATOR; // exact match if (path.endsWith(dependencies[ii].toString())) { match = entries[jj]; results.add(entries[jj]); break; // different version match } else if (path.indexOf(pattern) != -1) { break; } } else if (entries[jj].getEntryKind() == IClasspathEntry.CPE_PROJECT) { String path = entries[jj].getPath().toOSString(); if (path.endsWith(dependencies[ii].getName())) { match = entries[jj]; break; } } } if (match == null) { IClasspathEntry entry = createEntry(root, project, dependencies[ii]); results.add(entry); } else { match = null; } } return (IClasspathEntry[]) results.toArray(new IClasspathEntry[results.size()]); } /** * Determines if the supplied entry contains attribute indicating that it * should not be removed. * * @param entry The IClasspathEntry * @return true to preserve the entry, false otherwise. */ protected boolean preserve(IClasspathEntry entry) { IClasspathAttribute[] attributes = entry.getExtraAttributes(); for (int ii = 0; ii < attributes.length; ii++) { String name = attributes[ii].getName(); if (PRESERVE.equals(name)) { return Boolean.parseBoolean(attributes[ii].getValue()); } } return false; } /** * Creates the classpath entry. * * @param root The workspace root. * @param project The project to create the dependency in. * @param dependency The dependency to create the entry for. * @return The classpath entry. */ protected IClasspathEntry createEntry(IWorkspaceRoot root, IJavaProject project, Dependency dependency) throws Exception { if (dependency.isVariable()) { return JavaCore.newVariableEntry(dependency.getPath(), null, null, true); } return JavaCore.newLibraryEntry(dependency.getPath(), null, null, true); } /** * Determines if the supplied path starts with a variable name. * * @param path The path to test. * @return True if the path starts with a variable name, false otherwise. */ protected boolean startsWithVariable(String path) { String[] variables = JavaCore.getClasspathVariableNames(); for (int ii = 0; ii < variables.length; ii++) { if (path.startsWith(variables[ii])) { return true; } } return false; } }