// Licensed 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 net.sourceforge.eclipsejetty.util;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import net.sourceforge.eclipsejetty.JettyPlugin;
import net.sourceforge.eclipsejetty.JettyPluginM2EUtils;
import net.sourceforge.eclipsejetty.JettyPluginUtils;
import net.sourceforge.eclipsejetty.Messages;
import net.sourceforge.eclipsejetty.launch.util.JettyLaunchConfigurationAdapter;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.m2e.core.MavenPlugin;
import org.eclipse.m2e.core.embedder.ArtifactRef;
import org.eclipse.m2e.core.project.IMavenProjectFacade;
import org.eclipse.m2e.core.project.IMavenProjectRegistry;
/**
* A map holding all {@link MavenDependencyInfo}s
*
* @author Manfred Hantschel
*/
public class MavenDependencyInfoMap
{
private final Map<String, MavenDependencyInfo> dependencies = new HashMap<String, MavenDependencyInfo>();
/**
* Creates the infos from the classpath
*
* @param adapter the configuration adapter
* @param runtimeClasspathEntries the classpath entries
* @throws CoreException on occasion
*/
public MavenDependencyInfoMap(JettyLaunchConfigurationAdapter adapter,
IRuntimeClasspathEntry... runtimeClasspathEntries) throws CoreException
{
super();
if (!JettyPluginM2EUtils.isM2EAvailable())
{
return;
}
IMavenProjectRegistry mavenProjectRegistry = MavenPlugin.getMavenProjectRegistry();
IProject project = adapter.getProject();
if (project != null)
{
IProject[] referencedProjects = project.getReferencedProjects();
if (referencedProjects != null)
{
for (IProject referencedProject : referencedProjects)
{
IMavenProjectFacade facade = mavenProjectRegistry.getProject(referencedProject);
if (facade != null)
{
buildLocations(facade);
}
}
}
}
IMavenProjectFacade facade = JettyPluginM2EUtils.getMavenProjectFacade(adapter);
if (facade == null)
{
return;
}
buildLocations(facade);
Set<ArtifactRef> artifactsRefs = facade.getMavenProjectArtifacts();
for (ArtifactRef artifactRef : artifactsRefs)
{
buildArtifact(artifactRef);
}
}
private void buildLocations(IMavenProjectFacade facade)
{
addLocations(facade, "output", MavenScope.COMPILE, facade.getOutputLocation()); //$NON-NLS-1$
addLocations(facade, "resource", MavenScope.RUNTIME, facade.getResourceLocations()); //$NON-NLS-1$
addLocations(facade, "test-output", MavenScope.TEST, facade.getTestOutputLocation()); //$NON-NLS-1$
addLocations(facade, "test-resource", MavenScope.TEST, facade.getTestResourceLocations()); //$NON-NLS-1$
}
private void addLocations(IMavenProjectFacade facade, String variant, MavenScope scope, IPath... paths)
{
if ((paths == null) || (paths.length == 0))
{
return;
}
MavenDependencyInfo dependency = MavenDependencyInfo.create(facade, variant, scope);
for (IPath path : paths)
{
String location = toLocation(facade, path);
if (location != null)
{
dependencies.put(location, dependency);
}
}
}
private void buildArtifact(ArtifactRef artifactRef)
{
String portableString = artifactRef.getArtifactKey().toPortableString();
dependencies.put(portableString, MavenDependencyInfo.create(artifactRef));
}
/**
* Returns the info for the specified classpath entry
*
* @param runtimeClasspathEntry the entry
* @return the info, null if not found
*/
public MavenDependencyInfo resolve(IRuntimeClasspathEntry runtimeClasspathEntry)
{
MavenDependencyInfo suspectedMavenDependency = MavenDependencyInfo.create(runtimeClasspathEntry);
String location = JettyPluginUtils.toLocation(runtimeClasspathEntry);
if (suspectedMavenDependency != null)
{
String suspectedMavenDependencyPortableString = suspectedMavenDependency.toPortableString();
MavenDependencyInfo mavenDependency = dependencies.get(suspectedMavenDependencyPortableString);
if (mavenDependency != null)
{
if (!JettyPluginUtils.equals(suspectedMavenDependency.getScope(), mavenDependency.getScope()))
{
JettyPlugin.info(String.format(Messages.dependencyMap_fixedScope, location,
suspectedMavenDependency.getScope(), mavenDependency.getScope()));
}
return mavenDependency;
}
}
MavenDependencyInfo mavenDependency = dependencies.get(location);
if (mavenDependency != null)
{
return mavenDependency;
}
// add more checks here
return null;
}
/**
* Converts the path to an absolute location in the file system. Returns null if the path could not be determined.
*
* @param facade the facade of the reference project
* @param path the path
* @return the absolute location, null if unknown
*/
public static String toLocation(IMavenProjectFacade facade, IPath path)
{
if (path == null)
{
return null;
}
IProject project = facade.getProject();
if (project == null)
{
JettyPlugin.info(String.format("Failed to determine project reference of %s", facade.getArtifactKey()
.toPortableString()));
return null;
}
IPath location = project.getLocation();
if (location == null)
{
JettyPlugin.info(String.format("Failed to determine location of project %s", project.getName()));
return null;
}
return location.append(path.makeRelativeTo(facade.getFullPath())).toString();
}
}