java/projectimport.eclipse.core/src/org/netbeans/modules/projectimport/eclipse/core/EclipseProject.java - netbeans - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.netbeans.modules.projectimport.eclipse.core;

 import java.io.File;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.logging.Logger;
 import org.netbeans.modules.projectimport.eclipse.core.spi.DotClassPathEntry;
 import org.netbeans.modules.projectimport.eclipse.core.spi.Facets;
 import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectTypeFactory;
 import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectTypeFactory.ProjectDescriptor;
 import org.netbeans.spi.project.support.ant.EditableProperties;
 import org.netbeans.spi.project.support.ant.PropertyUtils;
 import org.openide.util.Exceptions;
 import org.openide.util.Lookup;
 import org.openide.util.NbBundle;
 import org.openide.util.Utilities;

 /**
  * Represents Eclipse project structure.
  *
  * @author mkrauskopf
  */
 public final class EclipseProject implements Comparable {

     /** Logger for this class. */
     private static final Logger logger =
             Logger.getLogger(EclipseProject.class.getName());

     private static final Lookup.Result<? extends ProjectTypeFactory> projectTypeFactories =
         Lookup.getDefault().lookupResult (ProjectTypeFactory.class);

     private Boolean importSupported;
     private ProjectTypeFactory projectFactory;
     private Set<EclipseProject> projectsWeDependOn;

     static final String PROJECT_FILE = ".project"; // NOI18N
     static final String CLASSPATH_FILE = ".classpath"; // NOI18N

     private Workspace workspace;

     private String name;
     private boolean internal = true;
     private DotClassPath cp;
     private Set<String> natures;
     private List<Link> links;

     private final File projectDir;
     private final File cpFile;
     private final File prjFile;
     private String jdkDirectory;

     private List<String> importProblems = new ArrayList<String>();

     private Facets projectFacets;

     /**
      * Returns <code>EclipseProject</code> instance representing Eclipse project
      * found in the given <code>projectDir</code>. If a project is not found in
      * the specified directory, <code>null</code> is returned.
      *
      * @return either a <code>EclipseProject</code> instance or null if a given
      *      <code>projectDir</code> doesn't contain valid Eclipse project.
      */
     static EclipseProject createProject(File projectDir) {
         if (!EclipseUtils.isRegularProject(projectDir)) {
             logger.fine(projectDir + " doesn't contain regular Eclipse project."); // NOI18N
             return null;
         }
         return new EclipseProject(projectDir);
     }

     /** Sets up a project directory. */
     /*private*/ EclipseProject(File projectDir) {
         this.projectDir = projectDir;
         File f = new File(projectDir, CLASSPATH_FILE);
         this.cpFile = f.exists() ? f : null;
         this.prjFile = new File(projectDir, PROJECT_FILE);
     }

     void removeInvalidSourceRoots(List<String> projectImportProblems) {
         List<DotClassPathEntry> projectSources = new ArrayList<DotClassPathEntry>();
         for (DotClassPathEntry e : getSourceRoots()) {
             if (new File(e.getAbsolutePath()).exists()) {
                 projectSources.add(e);
             } else {
                 projectImportProblems.add(
                     NbBundle.getMessage(EclipseProject.class, "MSG_InvalidSourceRoot", e.getRawPath())); //NOI18N
             }
         }
         cp.updateSourceRoots(projectSources);
     }

     void setFacets(Facets projectFacets) {
         this.projectFacets = projectFacets;
     }

     public Facets getFacets() {
         return projectFacets;
     }

     void setLinks(List<Link> links) {
         this.links = links;
     }

     List<Link> getLinks() {
         return links;
     }


     void setNatures(Set<String> natures) {
         this.natures = natures;
     }

     void setWorkspace(Workspace workspace) {
         this.workspace = workspace;
     }

     public Workspace getWorkspace() {
         return workspace;
     }

     void setClassPath(DotClassPath cp) {
         this.cp = cp;
         calculateAbsolutePaths();
         convertFileVariablesToFolderVariables();
         updateSourcePathAttribute();
         updateJavadocLocationAttribute();
         try {
             resolveContainers(new ArrayList<String>(), false);
         } catch (IOException ex) {
             Exceptions.printStackTrace(ex);
         }
     }

     public List<DotClassPathEntry> getClassPathEntries() {
         return cp.getClassPathEntries();
     }

     /**
      * Returns project's name.
      */
     public String getName() {
         return name;
     }

     void setName(String name) {
         this.name = name;
     }

     void setInternal(boolean internal) {
         this.internal = internal;
     }

     public boolean isInternal() {
         return internal;
     }

     public File getDirectory() {
         return projectDir;
     }

     /**
      * Returns metadata file containing information about this projects. I.e.
      * normally <em>.project</em> file withing the project's directory. See
      * {@link #PROJECT_FILE}.
      */
     File getProjectFile() {
         return prjFile;
     }

     /**
      * Returns metadata file containing information about this projects. I.e.
      * normally <em>.classpath</em> file withing the project's directory. See
      * {@link #CLASSPATH_FILE}.
      */
     File getClassPathFile() {
         return cpFile;
     }

     public Set<String> getNatures() {
         return natures;
     }

     /**
      * Can this Eclipse project be converted to NetBeans or not?
      */
     public boolean isImportSupported() {
         performRecognitionIfNeeded();
         return importSupported.booleanValue();
     }

     public ProjectTypeFactory getProjectTypeFactory() {
         performRecognitionIfNeeded();
         return projectFactory;
     }

     private ProjectDescriptor getProjectDescriptor() {
         return new ProjectTypeFactory.ProjectDescriptor(getDirectory(), natures, projectFacets);
     }

     File  getProjectFileLocation(String token) {
         if (!isImportSupported()) {
             return null;
         }
         return getProjectTypeFactory().getProjectFileLocation(getProjectDescriptor(), token);
     }

     private void performRecognitionIfNeeded() {
         if (importSupported == null) {
             importSupported = Boolean.FALSE;
             for (ProjectTypeFactory factory : projectTypeFactories.allInstances()) {
                 if (factory.canHandle(getProjectDescriptor())) {
                     this.projectFactory = factory;
                     importSupported = Boolean.TRUE;
                     break;
                 }
             }
         }
     }

     /**
      * Returns JDK directory for platform this project uses. Can be null in a
      * case when a JDK was set for an eclipse project in Eclipse then the
      * directory with JDK was deleted from filesystem and then a project is
      * imported to NetBeans.
      *
      * @return JDK directory for the project
      */
     public String getJDKDirectory() {
         if (jdkDirectory == null && workspace != null && cp.getJREContainer() != null) {
             logger.finest("Getting JDK directory for project " + this.getName()); // NOI18N
             jdkDirectory = workspace.getJDKDirectory(cp.getJREContainer().getRawPath());
             logger.finest("Resolved JDK directory: " + jdkDirectory); // NOI18N
             // jdkDirectory = workspace.getJDKDirectory(projectDir.getName());
         }
         return jdkDirectory;
     }

     /** Convenient delegate to <code>ClassPath</code> */
     public List<DotClassPathEntry> getSourceRoots() {
         return cp.getSourceRoots();
     }

     /**
      * Returns collection of <code>EclipseProject</code> this project requires.
      */
     public Set<EclipseProject> getProjects() {
         if (workspace != null && projectsWeDependOn == null) {
             projectsWeDependOn = new HashSet<EclipseProject>();
             for (DotClassPathEntry entry : getClassPathEntries()) {
                 if (entry.getKind() != DotClassPathEntry.Kind.PROJECT) {
                     continue;
                 }
                 EclipseProject prj = workspace.getProjectByRawPath(entry.getRawPath());
                 if (prj != null) {
                     projectsWeDependOn.add(prj);
                 }
             }
         }
         return projectsWeDependOn == null ?
             Collections.<EclipseProject>emptySet() : projectsWeDependOn;
     }

     void resolveContainers(List<String> importProblems, boolean importInProgress) throws IOException {
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             if (entry.getKind() != DotClassPathEntry.Kind.CONTAINER) {
                 continue;
             }
             ClassPathContainerResolver.resolve(workspace, entry, importProblems, importInProgress);
         }
     }

     void replaceContainers() {
         List<DotClassPathEntry> newCp = new ArrayList<DotClassPathEntry>();
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             if (entry.getKind() != DotClassPathEntry.Kind.CONTAINER) {
                 newCp.add(entry);
                 continue;
             }
             List<DotClassPathEntry> repl = ClassPathContainerResolver.replaceContainerEntry(this, workspace, entry, importProblems);
             if (repl != null) {
                 newCp.addAll(repl);
             } else {
                 newCp.add(entry);
             }
         }
         cp.updateClasspath(newCp);
     }

     void setupEnvironmentVariables(List<String> importProblems) throws IOException {
         if (workspace == null) {
             return;
         }
         EditableProperties ep = PropertyUtils.getGlobalProperties();
         boolean changed = false;
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             if (entry.getKind() != DotClassPathEntry.Kind.VARIABLE) {
                 continue;
             }
             String s = EclipseUtils.splitVariable(entry.getRawPath())[0];
             Workspace.Variable v = getVariable(s);
             if (v != null) {
                 s = "var."+PropertyUtils.getUsablePropertyName(s); //NOI18N
                 if (ep.getProperty(s) == null) {
                     ep.setProperty(s, v.getLocation());
                     changed = true;
                 } else if (!ep.getProperty(s).equals(v.getLocation())) {
                     importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_IDEVariableMismatch", s, ep.getProperty(s), v.getLocation())); //NOI18N
                 }
             } else {
                 importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_IDEVariableNotFound", s)); //NOI18N
                 ep.setProperty(s, ""); //NOI18N
                 changed = true;
             }
         }
         if (changed) {
             PropertyUtils.putGlobalProperties(ep);
         }
     }

     void convertFileVariablesToFolderVariables() {
         if (workspace == null) {
             return;
         }
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             if (entry.getKind() != DotClassPathEntry.Kind.VARIABLE) {
                 continue;
             }
             String s = EclipseUtils.splitVariable(entry.getRawPath())[0];
             Workspace.Variable v = getVariable(s);
             if (v != null && v.isFileVariable()) {
                 // convert eclipse file variable to folder variable
                 entry.updateVariableValue(v.getName()+'/'+v.getFileName());
             }
         }
     }

     private void updateSourcePathAttribute() {
         if (workspace == null) {
             return;
         }
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             String sourcePath = entry.getProperty(DotClassPathEntry.ATTRIBUTE_SOURCEPATH);
             if (sourcePath == null) {
                 continue;
             }
             String resolvedPath = resolveSourcePathAttribute(sourcePath, workspace, true);
             if (resolvedPath != null) {
                 entry.updateSourcePath(resolvedPath);
             }
         }
     }

     static String resolveSourcePathAttribute(String sourcePath, Workspace workspace, boolean useVariables) {
         String resolvedPath = resolvePath(sourcePath, workspace);
         if (resolvedPath != null) {
             return resolvedPath;
         }
         // test whether sourcePath starts with variable:
         for (Workspace.Variable v : workspace.getVariables()) {
             if (sourcePath.startsWith(v.getName())) {
                 String s[] = EclipseUtils.splitVariable(sourcePath);
                 // change value to Ant style property directly usable in NB:
                 if (useVariables) {
                     return "${"+s[0]+"}"+s[1]; // NOI18N
                 } else {
                     return v.getLocation() + s[1];
                 }
             }
         }
         return null;
     }

     private void updateJavadocLocationAttribute() {
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             String javadoc = entry.getProperty(DotClassPathEntry.ATTRIBUTE_JAVADOC);
             if (javadoc == null) {
                 continue;
             }
             entry.updateJavadoc(resolveJavadocLocationAttribute(javadoc, workspace, importProblems, false));
         }
     }

     static String resolveJavadocLocationAttribute(String javadoc, Workspace workspace, List<String> importProblems, boolean returnURL) {
         String jarPath = null;
         // strip off jar protocol; because of 'platform' protocol which is
         // undefined in NB the FileUtil.getArchiveFile will not be used here
         if (javadoc.startsWith("jar:")) { // NOI18N
             jarPath = javadoc.substring(javadoc.indexOf("!/")); //NOI18N
             if (!jarPath.endsWith("/")) { //NOI18N
                 jarPath += "/"; //NOI18N
             }
             javadoc = javadoc.substring(4, javadoc.indexOf("!/")); //NOI18N
         }
         if (javadoc.startsWith("platform:/resource")) { // NOI18N
             if (workspace == null) {
                 importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_WorkspaceDependentProtocol", javadoc)); //NOI18N
                 return null;
             }
             String s = resolvePath(javadoc.substring(18), workspace);
             if (s != null) {
                 if (returnURL) {
                     try {
                         s = Utilities.toURI(new File(s)).toURL().toExternalForm();
                         if (jarPath != null) {
                             s = "jar:"+s+jarPath;
                         }
                         return s;
                     } catch (MalformedURLException ex) {
                         Exceptions.printStackTrace(ex);
                         return null;
                     }
                 } else {
                     if (jarPath != null) {
                         s += jarPath;
                     }
                     return s;
                 }
             }
         }
         if (javadoc.startsWith("platform")) { // NOI18N
             importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_UnsupportedProtocol", javadoc)); //NOI18N
             return null;
         }
         // copied from FileUtil.getArchiveFile
         if (javadoc.indexOf("file://") > -1 && javadoc.indexOf("file:////") == -1) {  //NOI18N
             /* Replace because JDK application classloader wrongly recognizes UNC paths. */
             javadoc = javadoc.replaceFirst("file://", "file:////");  //NOI18N
         }
         URL u;
         try {
             u = new URL(javadoc);
         } catch (MalformedURLException ex) {
             importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_UnsupportedJavadocLocation", javadoc));
             return null;
         }
         if (!"file".equals(u.getProtocol())) { // NOI18N
             // XXX this is just a warning rather then import problem
             // Perhaps instead of List<String> for import problems define
             // a class which could have two lists: import problems and import warnings
             importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_UnsupportedProtocol", u.toExternalForm()));
             return null;
         }
         try {
             if (returnURL) {
                 if (jarPath != null) {
                     return "jar:"+u.toExternalForm()+jarPath;
                 } else {
                     return u.toExternalForm();
                 }
             } else {
                 File f = Utilities.toFile(u.toURI());
                 String path = f.getPath();
                 if (jarPath != null) {
                     path += jarPath;
                 }
                 return path;
             }
         } catch (URISyntaxException ex) {
             importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_JavadocCannotBeResolved", u.toExternalForm()));
         }
         return null;
     }

     public List<String> getImportProblems() {
         return importProblems;
     }

     private void calculateAbsolutePaths() {
         for (DotClassPathEntry entry : cp.getClassPathEntries()) {
             setAbsolutePathForEntry(entry);
         }
         for (DotClassPathEntry entry : cp.getSourceRoots()) {
             setAbsolutePathForEntry(entry);
         }
         setAbsolutePathForEntry(cp.getOutput());
     }

     public DotClassPathEntry getOutput() {
         return cp.getOutput();
     }

     /**
      * Inteligently sets absolute path for a given entry with recongnizing of
      * links, projects, variables, relative and absolute entries.
      * If it is not possible (e.g. workspace Varible is not found) sets abs.
      * path to null.
      */
     private void setAbsolutePathForEntry(DotClassPathEntry entry) {
         if (entry == null) {
             return;
         }
         // set abs. path default (null)
         entry.setAbsolutePath(null);

         // try to resolve entry as a CONTAINER
         if (entry.getKind() == DotClassPathEntry.Kind.CONTAINER) {
             // we don't support CONTAINERs so we don't care about them here
             // (we support JRE/JDK containers but those are solved elsewhere)
             return;
         }

         // try to resolve entry as a VARIABLE
         if (entry.getKind() == DotClassPathEntry.Kind.VARIABLE) {
             String var[] = EclipseUtils.splitVariable(entry.getRawPath());
             Workspace.Variable variable = getVariable(var[0]);
             if (variable != null) {
                 entry.setAbsolutePath(variable.getLocation() +var[1]);
             } else {
                 logger.warning("cannot resolve variable '"+var[0]+"'. used in project "+ //NOI18N
                         getProjectFile().getPath()+" in entry "+entry); //NOI18N
             }
             return;
         }

         // try to resolve entry as a PROJECT
         if (entry.getKind() == DotClassPathEntry.Kind.PROJECT) {
             if (workspace != null) {
                 EclipseProject ep = workspace.getProjectByName(entry.getRawPath().substring(1));
                 if (ep != null) {
                     entry.setAbsolutePath(ep.getDirectory().getAbsolutePath());
                 }
             }
             //            else {
             //                ErrorManager.getDefault().log(ErrorManager.WARNING, "workspace == null");
             //            }
             return;
         }

         // not VARIABLE, not PROJECT, not LINK -> either source root or library
         boolean resolved = false;
         String path = entry.getRawPath();
         // first check whether path starts with a project name:
         if (entry.getKind() == DotClassPathEntry.Kind.LIBRARY && workspace != null) {
             String s = resolvePath(path, workspace);
             if (s != null) {
                 path = s;
                 resolved = true;
             }
         }
         if (!resolved) {
             // convert possibly relative path to absolute:
             if (!Util.isAbsolutePath(path)) {
                 path = projectDir.getAbsolutePath()+File.separator+path;
                 resolved = true;
             }
         }
         entry.setAbsolutePath(path);
     }

     private static String resolvePath(String path, Workspace workspace) {
        File f = new File(path);
         // test whether it is file within a project, e.g. "/some-project/lib/file.jar"
         if (path.startsWith("/") && !f.exists()) { // NOI18N
             String s[] = EclipseUtils.splitProject(path);
             EclipseProject ep = workspace.getProjectByName(s[0]);
             if (ep != null) {
                 String projectPath = ep.getDirectory().getAbsolutePath();
                 String resolvedPath = resolveLinkPath(s[1], ep.links);
                 if (resolvedPath != null) {
                     return resolvedPath;
                 }
                 return projectPath + s[1];
             }
         }
         return null;
     }

     private static String resolveLinkPath(String path, List<Link> links) {
         if (path.startsWith("/") || path.startsWith("\\")) {
             // get rid of first slash
             path = path.substring(1);
         }
         for (Link l : links) {
             if (path.startsWith(l.getName())) {
                 return l.getLocation() + path.substring(l.getName().length());
             }
         }
         return null;
     }

     /**
      * Find variable for the given variable rawPath. Note that this method
      * returns <code>null</code> if workspace wasn't set for the project.
      */
     private Workspace.Variable getVariable(String rawPath) {
         if (workspace == null) {
             // workspace wasn't set for this project
             logger.fine("Workspace wasn't set for the project \"" + getName() + "\""); // NOI18N
             return null;
         }
         return workspace.getVariable(rawPath);
     }

     @Override
     public String toString() {
         return "EclipseProject[" + getName() + ", " + getDirectory() + "]"; // NOI18N
     }

     /* name is enough for now */
     @Override
     public boolean equals(Object obj) {
         if (this == obj) return true;
         if (!(obj instanceof EclipseProject)) return false;
         final EclipseProject ePrj = (EclipseProject) obj;
         if (!name.equals(ePrj.name)) return false;
         return true;
     }

     /* name is enough for now */
     @Override
     public int hashCode() {
         int result = 17;
         result = 37 * result + System.identityHashCode(name);
         return result;
     }

     /**
      * Compares projects based on theirs <code>name</code>s. Projects which has
      * null-name will be last.
      */
     public int compareTo(Object o) {
         String name1 = getName();
         String name2 = null;
         if (o instanceof EclipseProject) {
             name2 = ((EclipseProject) o).getName();
         }
         if (name2 == null) {
             return (name1 == null ? 0 : -1);
         }
         return (name1 == null ? 1 : name1.compareToIgnoreCase(name2));
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.netbeans.modules.projectimport.eclipse.core;

	import java.io.File;
	import java.io.IOException;
	import java.net.MalformedURLException;
	import java.net.URISyntaxException;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.logging.Logger;
	import org.netbeans.modules.projectimport.eclipse.core.spi.DotClassPathEntry;
	import org.netbeans.modules.projectimport.eclipse.core.spi.Facets;
	import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectTypeFactory;
	import org.netbeans.modules.projectimport.eclipse.core.spi.ProjectTypeFactory.ProjectDescriptor;
	import org.netbeans.spi.project.support.ant.EditableProperties;
	import org.netbeans.spi.project.support.ant.PropertyUtils;
	import org.openide.util.Exceptions;
	import org.openide.util.Lookup;
	import org.openide.util.NbBundle;
	import org.openide.util.Utilities;

	/**
	* Represents Eclipse project structure.
	*
	* @author mkrauskopf
	*/
	public final class EclipseProject implements Comparable {

	/** Logger for this class. */
	private static final Logger logger =
	Logger.getLogger(EclipseProject.class.getName());

	private static final Lookup.Result<? extends ProjectTypeFactory> projectTypeFactories =
	Lookup.getDefault().lookupResult (ProjectTypeFactory.class);

	private Boolean importSupported;
	private ProjectTypeFactory projectFactory;
	private Set<EclipseProject> projectsWeDependOn;

	static final String PROJECT_FILE = ".project"; // NOI18N
	static final String CLASSPATH_FILE = ".classpath"; // NOI18N

	private Workspace workspace;

	private String name;
	private boolean internal = true;
	private DotClassPath cp;
	private Set<String> natures;
	private List<Link> links;

	private final File projectDir;
	private final File cpFile;
	private final File prjFile;
	private String jdkDirectory;

	private List<String> importProblems = new ArrayList<String>();

	private Facets projectFacets;

	/**
	* Returns <code>EclipseProject</code> instance representing Eclipse project
	* found in the given <code>projectDir</code>. If a project is not found in
	* the specified directory, <code>null</code> is returned.
	*
	* @return either a <code>EclipseProject</code> instance or null if a given
	* <code>projectDir</code> doesn't contain valid Eclipse project.
	*/
	static EclipseProject createProject(File projectDir) {
	if (!EclipseUtils.isRegularProject(projectDir)) {
	logger.fine(projectDir + " doesn't contain regular Eclipse project."); // NOI18N
	return null;
	}
	return new EclipseProject(projectDir);
	}

	/** Sets up a project directory. */
	/private/ EclipseProject(File projectDir) {
	this.projectDir = projectDir;
	File f = new File(projectDir, CLASSPATH_FILE);
	this.cpFile = f.exists() ? f : null;
	this.prjFile = new File(projectDir, PROJECT_FILE);
	}

	void removeInvalidSourceRoots(List<String> projectImportProblems) {
	List<DotClassPathEntry> projectSources = new ArrayList<DotClassPathEntry>();
	for (DotClassPathEntry e : getSourceRoots()) {
	if (new File(e.getAbsolutePath()).exists()) {
	projectSources.add(e);
	} else {
	projectImportProblems.add(
	NbBundle.getMessage(EclipseProject.class, "MSG_InvalidSourceRoot", e.getRawPath())); //NOI18N
	}
	}
	cp.updateSourceRoots(projectSources);
	}

	void setFacets(Facets projectFacets) {
	this.projectFacets = projectFacets;
	}

	public Facets getFacets() {
	return projectFacets;
	}

	void setLinks(List<Link> links) {
	this.links = links;
	}

	List<Link> getLinks() {
	return links;
	}


	void setNatures(Set<String> natures) {
	this.natures = natures;
	}

	void setWorkspace(Workspace workspace) {
	this.workspace = workspace;
	}

	public Workspace getWorkspace() {
	return workspace;
	}

	void setClassPath(DotClassPath cp) {
	this.cp = cp;
	calculateAbsolutePaths();
	convertFileVariablesToFolderVariables();
	updateSourcePathAttribute();
	updateJavadocLocationAttribute();
	try {
	resolveContainers(new ArrayList<String>(), false);
	} catch (IOException ex) {
	Exceptions.printStackTrace(ex);
	}
	}

	public List<DotClassPathEntry> getClassPathEntries() {
	return cp.getClassPathEntries();
	}

	/**
	* Returns project's name.
	*/
	public String getName() {
	return name;
	}

	void setName(String name) {
	this.name = name;
	}

	void setInternal(boolean internal) {
	this.internal = internal;
	}

	public boolean isInternal() {
	return internal;
	}

	public File getDirectory() {
	return projectDir;
	}

	/**
	* Returns metadata file containing information about this projects. I.e.
	* normally <em>.project</em> file withing the project's directory. See
	* {@link #PROJECT_FILE}.
	*/
	File getProjectFile() {
	return prjFile;
	}

	/**
	* Returns metadata file containing information about this projects. I.e.
	* normally <em>.classpath</em> file withing the project's directory. See
	* {@link #CLASSPATH_FILE}.
	*/
	File getClassPathFile() {
	return cpFile;
	}

	public Set<String> getNatures() {
	return natures;
	}

	/**
	* Can this Eclipse project be converted to NetBeans or not?
	*/
	public boolean isImportSupported() {
	performRecognitionIfNeeded();
	return importSupported.booleanValue();
	}

	public ProjectTypeFactory getProjectTypeFactory() {
	performRecognitionIfNeeded();
	return projectFactory;
	}

	private ProjectDescriptor getProjectDescriptor() {
	return new ProjectTypeFactory.ProjectDescriptor(getDirectory(), natures, projectFacets);
	}

	File getProjectFileLocation(String token) {
	if (!isImportSupported()) {
	return null;
	}
	return getProjectTypeFactory().getProjectFileLocation(getProjectDescriptor(), token);
	}

	private void performRecognitionIfNeeded() {
	if (importSupported == null) {
	importSupported = Boolean.FALSE;
	for (ProjectTypeFactory factory : projectTypeFactories.allInstances()) {
	if (factory.canHandle(getProjectDescriptor())) {
	this.projectFactory = factory;
	importSupported = Boolean.TRUE;
	break;
	}
	}
	}
	}

	/**
	* Returns JDK directory for platform this project uses. Can be null in a
	* case when a JDK was set for an eclipse project in Eclipse then the
	* directory with JDK was deleted from filesystem and then a project is
	* imported to NetBeans.
	*
	* @return JDK directory for the project
	*/
	public String getJDKDirectory() {
	if (jdkDirectory == null && workspace != null && cp.getJREContainer() != null) {
	logger.finest("Getting JDK directory for project " + this.getName()); // NOI18N
	jdkDirectory = workspace.getJDKDirectory(cp.getJREContainer().getRawPath());
	logger.finest("Resolved JDK directory: " + jdkDirectory); // NOI18N
	// jdkDirectory = workspace.getJDKDirectory(projectDir.getName());
	}
	return jdkDirectory;
	}

	/** Convenient delegate to <code>ClassPath</code> */
	public List<DotClassPathEntry> getSourceRoots() {
	return cp.getSourceRoots();
	}

	/**
	* Returns collection of <code>EclipseProject</code> this project requires.
	*/
	public Set<EclipseProject> getProjects() {
	if (workspace != null && projectsWeDependOn == null) {
	projectsWeDependOn = new HashSet<EclipseProject>();
	for (DotClassPathEntry entry : getClassPathEntries()) {
	if (entry.getKind() != DotClassPathEntry.Kind.PROJECT) {
	continue;
	}
	EclipseProject prj = workspace.getProjectByRawPath(entry.getRawPath());
	if (prj != null) {
	projectsWeDependOn.add(prj);
	}
	}
	}
	return projectsWeDependOn == null ?
	Collections.<EclipseProject>emptySet() : projectsWeDependOn;
	}

	void resolveContainers(List<String> importProblems, boolean importInProgress) throws IOException {
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	if (entry.getKind() != DotClassPathEntry.Kind.CONTAINER) {
	continue;
	}
	ClassPathContainerResolver.resolve(workspace, entry, importProblems, importInProgress);
	}
	}

	void replaceContainers() {
	List<DotClassPathEntry> newCp = new ArrayList<DotClassPathEntry>();
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	if (entry.getKind() != DotClassPathEntry.Kind.CONTAINER) {
	newCp.add(entry);
	continue;
	}
	List<DotClassPathEntry> repl = ClassPathContainerResolver.replaceContainerEntry(this, workspace, entry, importProblems);
	if (repl != null) {
	newCp.addAll(repl);
	} else {
	newCp.add(entry);
	}
	}
	cp.updateClasspath(newCp);
	}

	void setupEnvironmentVariables(List<String> importProblems) throws IOException {
	if (workspace == null) {
	return;
	}
	EditableProperties ep = PropertyUtils.getGlobalProperties();
	boolean changed = false;
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	if (entry.getKind() != DotClassPathEntry.Kind.VARIABLE) {
	continue;
	}
	String s = EclipseUtils.splitVariable(entry.getRawPath())[0];
	Workspace.Variable v = getVariable(s);
	if (v != null) {
	s = "var."+PropertyUtils.getUsablePropertyName(s); //NOI18N
	if (ep.getProperty(s) == null) {
	ep.setProperty(s, v.getLocation());
	changed = true;
	} else if (!ep.getProperty(s).equals(v.getLocation())) {
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_IDEVariableMismatch", s, ep.getProperty(s), v.getLocation())); //NOI18N
	}
	} else {
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_IDEVariableNotFound", s)); //NOI18N
	ep.setProperty(s, ""); //NOI18N
	changed = true;
	}
	}
	if (changed) {
	PropertyUtils.putGlobalProperties(ep);
	}
	}

	void convertFileVariablesToFolderVariables() {
	if (workspace == null) {
	return;
	}
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	if (entry.getKind() != DotClassPathEntry.Kind.VARIABLE) {
	continue;
	}
	String s = EclipseUtils.splitVariable(entry.getRawPath())[0];
	Workspace.Variable v = getVariable(s);
	if (v != null && v.isFileVariable()) {
	// convert eclipse file variable to folder variable
	entry.updateVariableValue(v.getName()+'/'+v.getFileName());
	}
	}
	}

	private void updateSourcePathAttribute() {
	if (workspace == null) {
	return;
	}
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	String sourcePath = entry.getProperty(DotClassPathEntry.ATTRIBUTE_SOURCEPATH);
	if (sourcePath == null) {
	continue;
	}
	String resolvedPath = resolveSourcePathAttribute(sourcePath, workspace, true);
	if (resolvedPath != null) {
	entry.updateSourcePath(resolvedPath);
	}
	}
	}

	static String resolveSourcePathAttribute(String sourcePath, Workspace workspace, boolean useVariables) {
	String resolvedPath = resolvePath(sourcePath, workspace);
	if (resolvedPath != null) {
	return resolvedPath;
	}
	// test whether sourcePath starts with variable:
	for (Workspace.Variable v : workspace.getVariables()) {
	if (sourcePath.startsWith(v.getName())) {
	String s[] = EclipseUtils.splitVariable(sourcePath);
	// change value to Ant style property directly usable in NB:
	if (useVariables) {
	return "${"+s[0]+"}"+s[1]; // NOI18N
	} else {
	return v.getLocation() + s[1];
	}
	}
	}
	return null;
	}

	private void updateJavadocLocationAttribute() {
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	String javadoc = entry.getProperty(DotClassPathEntry.ATTRIBUTE_JAVADOC);
	if (javadoc == null) {
	continue;
	}
	entry.updateJavadoc(resolveJavadocLocationAttribute(javadoc, workspace, importProblems, false));
	}
	}

	static String resolveJavadocLocationAttribute(String javadoc, Workspace workspace, List<String> importProblems, boolean returnURL) {
	String jarPath = null;
	// strip off jar protocol; because of 'platform' protocol which is
	// undefined in NB the FileUtil.getArchiveFile will not be used here
	if (javadoc.startsWith("jar:")) { // NOI18N
	jarPath = javadoc.substring(javadoc.indexOf("!/")); //NOI18N
	if (!jarPath.endsWith("/")) { //NOI18N
	jarPath += "/"; //NOI18N
	}
	javadoc = javadoc.substring(4, javadoc.indexOf("!/")); //NOI18N
	}
	if (javadoc.startsWith("platform:/resource")) { // NOI18N
	if (workspace == null) {
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_WorkspaceDependentProtocol", javadoc)); //NOI18N
	return null;
	}
	String s = resolvePath(javadoc.substring(18), workspace);
	if (s != null) {
	if (returnURL) {
	try {
	s = Utilities.toURI(new File(s)).toURL().toExternalForm();
	if (jarPath != null) {
	s = "jar:"+s+jarPath;
	}
	return s;
	} catch (MalformedURLException ex) {
	Exceptions.printStackTrace(ex);
	return null;
	}
	} else {
	if (jarPath != null) {
	s += jarPath;
	}
	return s;
	}
	}
	}
	if (javadoc.startsWith("platform")) { // NOI18N
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_UnsupportedProtocol", javadoc)); //NOI18N
	return null;
	}
	// copied from FileUtil.getArchiveFile
	if (javadoc.indexOf("file://") > -1 && javadoc.indexOf("file:////") == -1) { //NOI18N
	/* Replace because JDK application classloader wrongly recognizes UNC paths. */
	javadoc = javadoc.replaceFirst("file://", "file:////"); //NOI18N
	}
	URL u;
	try {
	u = new URL(javadoc);
	} catch (MalformedURLException ex) {
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_UnsupportedJavadocLocation", javadoc));
	return null;
	}
	if (!"file".equals(u.getProtocol())) { // NOI18N
	// XXX this is just a warning rather then import problem
	// Perhaps instead of List<String> for import problems define
	// a class which could have two lists: import problems and import warnings
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_UnsupportedProtocol", u.toExternalForm()));
	return null;
	}
	try {
	if (returnURL) {
	if (jarPath != null) {
	return "jar:"+u.toExternalForm()+jarPath;
	} else {
	return u.toExternalForm();
	}
	} else {
	File f = Utilities.toFile(u.toURI());
	String path = f.getPath();
	if (jarPath != null) {
	path += jarPath;
	}
	return path;
	}
	} catch (URISyntaxException ex) {
	importProblems.add(org.openide.util.NbBundle.getMessage(EclipseProject.class, "MSG_JavadocCannotBeResolved", u.toExternalForm()));
	}
	return null;
	}

	public List<String> getImportProblems() {
	return importProblems;
	}

	private void calculateAbsolutePaths() {
	for (DotClassPathEntry entry : cp.getClassPathEntries()) {
	setAbsolutePathForEntry(entry);
	}
	for (DotClassPathEntry entry : cp.getSourceRoots()) {
	setAbsolutePathForEntry(entry);
	}
	setAbsolutePathForEntry(cp.getOutput());
	}

	public DotClassPathEntry getOutput() {
	return cp.getOutput();
	}

	/**
	* Inteligently sets absolute path for a given entry with recongnizing of
	* links, projects, variables, relative and absolute entries.
	* If it is not possible (e.g. workspace Varible is not found) sets abs.
	* path to null.
	*/
	private void setAbsolutePathForEntry(DotClassPathEntry entry) {
	if (entry == null) {
	return;
	}
	// set abs. path default (null)
	entry.setAbsolutePath(null);

	// try to resolve entry as a CONTAINER
	if (entry.getKind() == DotClassPathEntry.Kind.CONTAINER) {
	// we don't support CONTAINERs so we don't care about them here
	// (we support JRE/JDK containers but those are solved elsewhere)
	return;
	}

	// try to resolve entry as a VARIABLE
	if (entry.getKind() == DotClassPathEntry.Kind.VARIABLE) {
	String var[] = EclipseUtils.splitVariable(entry.getRawPath());
	Workspace.Variable variable = getVariable(var[0]);
	if (variable != null) {
	entry.setAbsolutePath(variable.getLocation() +var[1]);
	} else {
	logger.warning("cannot resolve variable '"+var[0]+"'. used in project "+ //NOI18N
	getProjectFile().getPath()+" in entry "+entry); //NOI18N
	}
	return;
	}

	// try to resolve entry as a PROJECT
	if (entry.getKind() == DotClassPathEntry.Kind.PROJECT) {
	if (workspace != null) {
	EclipseProject ep = workspace.getProjectByName(entry.getRawPath().substring(1));
	if (ep != null) {
	entry.setAbsolutePath(ep.getDirectory().getAbsolutePath());
	}
	}
	// else {
	// ErrorManager.getDefault().log(ErrorManager.WARNING, "workspace == null");
	// }
	return;
	}

	// not VARIABLE, not PROJECT, not LINK -> either source root or library
	boolean resolved = false;
	String path = entry.getRawPath();
	// first check whether path starts with a project name:
	if (entry.getKind() == DotClassPathEntry.Kind.LIBRARY && workspace != null) {
	String s = resolvePath(path, workspace);
	if (s != null) {
	path = s;
	resolved = true;
	}
	}
	if (!resolved) {
	// convert possibly relative path to absolute:
	if (!Util.isAbsolutePath(path)) {
	path = projectDir.getAbsolutePath()+File.separator+path;
	resolved = true;
	}
	}
	entry.setAbsolutePath(path);
	}

	private static String resolvePath(String path, Workspace workspace) {
	File f = new File(path);
	// test whether it is file within a project, e.g. "/some-project/lib/file.jar"
	if (path.startsWith("/") && !f.exists()) { // NOI18N
	String s[] = EclipseUtils.splitProject(path);
	EclipseProject ep = workspace.getProjectByName(s[0]);
	if (ep != null) {
	String projectPath = ep.getDirectory().getAbsolutePath();
	String resolvedPath = resolveLinkPath(s[1], ep.links);
	if (resolvedPath != null) {
	return resolvedPath;
	}
	return projectPath + s[1];
	}
	}
	return null;
	}

	private static String resolveLinkPath(String path, List<Link> links) {
	if (path.startsWith("/") \|\| path.startsWith("\\")) {
	// get rid of first slash
	path = path.substring(1);
	}
	for (Link l : links) {
	if (path.startsWith(l.getName())) {
	return l.getLocation() + path.substring(l.getName().length());
	}
	}
	return null;
	}

	/**
	* Find variable for the given variable rawPath. Note that this method
	* returns <code>null</code> if workspace wasn't set for the project.
	*/
	private Workspace.Variable getVariable(String rawPath) {
	if (workspace == null) {
	// workspace wasn't set for this project
	logger.fine("Workspace wasn't set for the project \"" + getName() + "\""); // NOI18N
	return null;
	}
	return workspace.getVariable(rawPath);
	}

	@Override
	public String toString() {
	return "EclipseProject[" + getName() + ", " + getDirectory() + "]"; // NOI18N
	}

	/* name is enough for now */
	@Override
	public boolean equals(Object obj) {
	if (this == obj) return true;
	if (!(obj instanceof EclipseProject)) return false;
	final EclipseProject ePrj = (EclipseProject) obj;
	if (!name.equals(ePrj.name)) return false;
	return true;
	}

	/* name is enough for now */
	@Override
	public int hashCode() {
	int result = 17;
	result = 37 * result + System.identityHashCode(name);
	return result;
	}

	/**
	* Compares projects based on theirs <code>name</code>s. Projects which has
	* null-name will be last.
	*/
	public int compareTo(Object o) {
	String name1 = getName();
	String name2 = null;
	if (o instanceof EclipseProject) {
	name2 = ((EclipseProject) o).getName();
	}
	if (name2 == null) {
	return (name1 == null ? 0 : -1);
	}
	return (name1 == null ? 1 : name1.compareToIgnoreCase(name2));
	}
	}