JavaProjectManager.java

/**
 * 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;
  }
}