| package org.apache.maven.project; |
| |
| /* |
| * 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. |
| */ |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.Writer; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.Objects; |
| |
| import org.apache.maven.RepositoryUtils; |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.artifact.ArtifactUtils; |
| import org.apache.maven.artifact.DependencyResolutionRequiredException; |
| // remove once createArtifacts() is removed |
| import org.apache.maven.artifact.factory.ArtifactFactory; |
| import org.apache.maven.artifact.repository.ArtifactRepository; |
| import org.apache.maven.artifact.resolver.filter.ArtifactFilter; |
| import org.apache.maven.model.Build; |
| import org.apache.maven.model.CiManagement; |
| import org.apache.maven.model.Contributor; |
| import org.apache.maven.model.Dependency; |
| import org.apache.maven.model.DependencyManagement; |
| import org.apache.maven.model.Developer; |
| import org.apache.maven.model.DistributionManagement; |
| import org.apache.maven.model.Extension; |
| import org.apache.maven.model.IssueManagement; |
| import org.apache.maven.model.License; |
| import org.apache.maven.model.MailingList; |
| import org.apache.maven.model.Model; |
| import org.apache.maven.model.Organization; |
| import org.apache.maven.model.Plugin; |
| import org.apache.maven.model.PluginExecution; |
| import org.apache.maven.model.PluginManagement; |
| import org.apache.maven.model.Prerequisites; |
| import org.apache.maven.model.Profile; |
| import org.apache.maven.model.ReportPlugin; |
| import org.apache.maven.model.ReportSet; |
| import org.apache.maven.model.Reporting; |
| import org.apache.maven.model.Repository; |
| import org.apache.maven.model.Resource; |
| import org.apache.maven.model.Scm; |
| import org.apache.maven.model.io.xpp3.MavenXpp3Writer; |
| import org.apache.maven.project.artifact.InvalidDependencyVersionException; |
| import org.apache.maven.project.artifact.MavenMetadataSource; |
| import org.codehaus.plexus.classworlds.realm.ClassRealm; |
| import org.codehaus.plexus.util.xml.Xpp3Dom; |
| import org.eclipse.aether.graph.DependencyFilter; |
| import org.eclipse.aether.repository.RemoteRepository; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * The concern of the project is provide runtime values based on the model. |
| * <p> |
| * The values in the model remain untouched but during the process of building a project notions like inheritance and |
| * interpolation can be added. This allows to have an entity which is useful in a runtime while preserving the model so |
| * that it can be marshalled and unmarshalled without being tainted by runtime requirements. |
| * </p> |
| * <p> |
| * With changes during 3.2.2 release MavenProject is closer to being immutable after construction with the removal of |
| * all components from this class, and the upfront construction taken care of entirely by the {@link ProjectBuilder}. |
| * There is still the issue of having to run the lifecycle in order to find all the compile source roots and resource |
| * directories but I hope to take care of this during the Maven 4.0 release (jvz). |
| * </p> |
| */ |
| public class MavenProject |
| implements Cloneable |
| { |
| |
| private static final Logger LOGGER = LoggerFactory.getLogger( MavenProject.class ); |
| |
| public static final String EMPTY_PROJECT_GROUP_ID = "unknown"; |
| |
| public static final String EMPTY_PROJECT_ARTIFACT_ID = "empty-project"; |
| |
| public static final String EMPTY_PROJECT_VERSION = "0"; |
| |
| private Model model; |
| |
| private MavenProject parent; |
| |
| private File file; |
| |
| private File basedir; |
| |
| private Set<Artifact> resolvedArtifacts; |
| |
| private ArtifactFilter artifactFilter; |
| |
| private Set<Artifact> artifacts; |
| |
| private Artifact parentArtifact; |
| |
| private Set<Artifact> pluginArtifacts; |
| |
| private List<ArtifactRepository> remoteArtifactRepositories; |
| |
| private List<ArtifactRepository> pluginArtifactRepositories; |
| |
| private List<RemoteRepository> remoteProjectRepositories; |
| |
| private List<RemoteRepository> remotePluginRepositories; |
| |
| private List<Artifact> attachedArtifacts = new ArrayList<>(); |
| |
| private MavenProject executionProject; |
| |
| private List<MavenProject> collectedProjects; |
| |
| private List<String> compileSourceRoots = new ArrayList<>(); |
| |
| private List<String> testCompileSourceRoots = new ArrayList<>(); |
| |
| private List<String> scriptSourceRoots = new ArrayList<>(); |
| |
| private ArtifactRepository releaseArtifactRepository; |
| |
| private ArtifactRepository snapshotArtifactRepository; |
| |
| private List<Profile> activeProfiles = new ArrayList<>(); |
| |
| private Map<String, List<String>> injectedProfileIds = new LinkedHashMap<>(); |
| |
| private Set<Artifact> dependencyArtifacts; |
| |
| private Artifact artifact; |
| |
| // calculated. |
| private Map<String, Artifact> artifactMap; |
| |
| private Model originalModel; |
| |
| private Map<String, Artifact> pluginArtifactMap; |
| |
| private Set<Artifact> reportArtifacts; |
| |
| private Map<String, Artifact> reportArtifactMap; |
| |
| private Set<Artifact> extensionArtifacts; |
| |
| private Map<String, Artifact> extensionArtifactMap; |
| |
| private Map<String, Artifact> managedVersionMap; |
| |
| private Map<String, MavenProject> projectReferences = new HashMap<>(); |
| |
| private boolean executionRoot; |
| |
| private File parentFile; |
| |
| private Map<String, Object> context; |
| |
| private ClassRealm classRealm; |
| |
| private DependencyFilter extensionDependencyFilter; |
| |
| private final Set<String> lifecyclePhases = Collections.synchronizedSet( new LinkedHashSet<>() ); |
| |
| public MavenProject() |
| { |
| Model model = new Model(); |
| |
| model.setGroupId( EMPTY_PROJECT_GROUP_ID ); |
| model.setArtifactId( EMPTY_PROJECT_ARTIFACT_ID ); |
| model.setVersion( EMPTY_PROJECT_VERSION ); |
| |
| setModel( model ); |
| } |
| |
| public MavenProject( Model model ) |
| { |
| setModel( model ); |
| } |
| |
| public MavenProject( MavenProject project ) |
| { |
| deepCopy( project ); |
| } |
| |
| public File getParentFile() |
| { |
| return parentFile; |
| } |
| |
| public void setParentFile( File parentFile ) |
| { |
| this.parentFile = parentFile; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Accessors |
| // ---------------------------------------------------------------------- |
| |
| public Artifact getArtifact() |
| { |
| return artifact; |
| } |
| |
| public void setArtifact( Artifact artifact ) |
| { |
| this.artifact = artifact; |
| } |
| |
| // TODO I would like to get rid of this. jvz. |
| public Model getModel() |
| { |
| return model; |
| } |
| |
| /** |
| * Returns the project corresponding to a declared parent. |
| * |
| * @return the parent, or null if no parent is declared or there was an error building it |
| */ |
| public MavenProject getParent() |
| { |
| return parent; |
| } |
| |
| public void setParent( MavenProject parent ) |
| { |
| this.parent = parent; |
| } |
| |
| public boolean hasParent() |
| { |
| return getParent() != null; |
| } |
| |
| public File getFile() |
| { |
| return file; |
| } |
| |
| public void setFile( File file ) |
| { |
| this.file = file; |
| this.basedir = file != null ? file.getParentFile() : null; |
| } |
| |
| /** |
| * Sets project {@code file} without changing project {@code basedir}. |
| * |
| * @since 3.2.4 |
| */ |
| public void setPomFile( File file ) |
| { |
| this.file = file; |
| } |
| |
| public File getBasedir() |
| { |
| return basedir; |
| } |
| |
| public void setDependencies( List<Dependency> dependencies ) |
| { |
| getModel().setDependencies( dependencies ); |
| } |
| |
| public List<Dependency> getDependencies() |
| { |
| return getModel().getDependencies(); |
| } |
| |
| public DependencyManagement getDependencyManagement() |
| { |
| return getModel().getDependencyManagement(); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Test and compile sourceroots. |
| // ---------------------------------------------------------------------- |
| |
| private void addPath( List<String> paths, String path ) |
| { |
| if ( path != null ) |
| { |
| path = path.trim(); |
| if ( path.length() > 0 ) |
| { |
| File file = new File( path ); |
| if ( file.isAbsolute() ) |
| { |
| path = file.getAbsolutePath(); |
| } |
| else if ( ".".equals( path ) ) |
| { |
| path = getBasedir().getAbsolutePath(); |
| } |
| else |
| { |
| path = new File( getBasedir(), path ).getAbsolutePath(); |
| } |
| |
| if ( !paths.contains( path ) ) |
| { |
| paths.add( path ); |
| } |
| } |
| } |
| } |
| |
| public void addCompileSourceRoot( String path ) |
| { |
| addPath( getCompileSourceRoots(), path ); |
| } |
| |
| public void addTestCompileSourceRoot( String path ) |
| { |
| addPath( getTestCompileSourceRoots(), path ); |
| } |
| |
| public List<String> getCompileSourceRoots() |
| { |
| return compileSourceRoots; |
| } |
| |
| public List<String> getTestCompileSourceRoots() |
| { |
| return testCompileSourceRoots; |
| } |
| |
| public List<String> getCompileClasspathElements() |
| throws DependencyResolutionRequiredException |
| { |
| List<String> list = new ArrayList<>( getArtifacts().size() + 1 ); |
| |
| String d = getBuild().getOutputDirectory(); |
| if ( d != null ) |
| { |
| list.add( d ); |
| } |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| if ( a.getArtifactHandler().isAddedToClasspath() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_COMPILE.equals( a.getScope() ) || Artifact.SCOPE_PROVIDED.equals( a.getScope() ) |
| || Artifact.SCOPE_SYSTEM.equals( a.getScope() ) ) |
| { |
| addArtifactPath( a, list ); |
| } |
| } |
| } |
| |
| return list; |
| } |
| |
| // TODO this checking for file == null happens because the resolver has been confused about the root |
| // artifact or not. things like the stupid dummy artifact coming from surefire. |
| public List<String> getTestClasspathElements() |
| throws DependencyResolutionRequiredException |
| { |
| List<String> list = new ArrayList<>( getArtifacts().size() + 2 ); |
| |
| String d = getBuild().getTestOutputDirectory(); |
| if ( d != null ) |
| { |
| list.add( d ); |
| } |
| |
| d = getBuild().getOutputDirectory(); |
| if ( d != null ) |
| { |
| list.add( d ); |
| } |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| if ( a.getArtifactHandler().isAddedToClasspath() ) |
| { |
| addArtifactPath( a, list ); |
| } |
| } |
| |
| return list; |
| } |
| |
| public List<String> getRuntimeClasspathElements() |
| throws DependencyResolutionRequiredException |
| { |
| List<String> list = new ArrayList<>( getArtifacts().size() + 1 ); |
| |
| String d = getBuild().getOutputDirectory(); |
| if ( d != null ) |
| { |
| list.add( d ); |
| } |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| if ( a.getArtifactHandler().isAddedToClasspath() |
| // TODO let the scope handler deal with this |
| && ( Artifact.SCOPE_COMPILE.equals( a.getScope() ) || Artifact.SCOPE_RUNTIME.equals( a.getScope() ) ) ) |
| { |
| addArtifactPath( a, list ); |
| } |
| } |
| return list; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Delegate to the model |
| // ---------------------------------------------------------------------- |
| |
| public void setModelVersion( String pomVersion ) |
| { |
| getModel().setModelVersion( pomVersion ); |
| } |
| |
| public String getModelVersion() |
| { |
| return getModel().getModelVersion(); |
| } |
| |
| public String getId() |
| { |
| return getModel().getId(); |
| } |
| |
| public void setGroupId( String groupId ) |
| { |
| getModel().setGroupId( groupId ); |
| } |
| |
| public String getGroupId() |
| { |
| String groupId = getModel().getGroupId(); |
| |
| if ( ( groupId == null ) && ( getModel().getParent() != null ) ) |
| { |
| groupId = getModel().getParent().getGroupId(); |
| } |
| |
| return groupId; |
| } |
| |
| public void setArtifactId( String artifactId ) |
| { |
| getModel().setArtifactId( artifactId ); |
| } |
| |
| public String getArtifactId() |
| { |
| return getModel().getArtifactId(); |
| } |
| |
| public void setName( String name ) |
| { |
| getModel().setName( name ); |
| } |
| |
| public String getName() |
| { |
| // TODO this should not be allowed to be null. |
| if ( getModel().getName() != null ) |
| { |
| return getModel().getName(); |
| } |
| else |
| { |
| return getArtifactId(); |
| } |
| } |
| |
| public void setVersion( String version ) |
| { |
| getModel().setVersion( version ); |
| } |
| |
| public String getVersion() |
| { |
| String version = getModel().getVersion(); |
| |
| if ( ( version == null ) && ( getModel().getParent() != null ) ) |
| { |
| version = getModel().getParent().getVersion(); |
| } |
| |
| return version; |
| } |
| |
| public String getPackaging() |
| { |
| return getModel().getPackaging(); |
| } |
| |
| public void setPackaging( String packaging ) |
| { |
| getModel().setPackaging( packaging ); |
| } |
| |
| public void setInceptionYear( String inceptionYear ) |
| { |
| getModel().setInceptionYear( inceptionYear ); |
| } |
| |
| public String getInceptionYear() |
| { |
| return getModel().getInceptionYear(); |
| } |
| |
| public void setUrl( String url ) |
| { |
| getModel().setUrl( url ); |
| } |
| |
| public String getUrl() |
| { |
| return getModel().getUrl(); |
| } |
| |
| public Prerequisites getPrerequisites() |
| { |
| return getModel().getPrerequisites(); |
| } |
| |
| public void setIssueManagement( IssueManagement issueManagement ) |
| { |
| getModel().setIssueManagement( issueManagement ); |
| } |
| |
| public CiManagement getCiManagement() |
| { |
| return getModel().getCiManagement(); |
| } |
| |
| public void setCiManagement( CiManagement ciManagement ) |
| { |
| getModel().setCiManagement( ciManagement ); |
| } |
| |
| public IssueManagement getIssueManagement() |
| { |
| return getModel().getIssueManagement(); |
| } |
| |
| public void setDistributionManagement( DistributionManagement distributionManagement ) |
| { |
| getModel().setDistributionManagement( distributionManagement ); |
| } |
| |
| public DistributionManagement getDistributionManagement() |
| { |
| return getModel().getDistributionManagement(); |
| } |
| |
| public void setDescription( String description ) |
| { |
| getModel().setDescription( description ); |
| } |
| |
| public String getDescription() |
| { |
| return getModel().getDescription(); |
| } |
| |
| public void setOrganization( Organization organization ) |
| { |
| getModel().setOrganization( organization ); |
| } |
| |
| public Organization getOrganization() |
| { |
| return getModel().getOrganization(); |
| } |
| |
| public void setScm( Scm scm ) |
| { |
| getModel().setScm( scm ); |
| } |
| |
| public Scm getScm() |
| { |
| return getModel().getScm(); |
| } |
| |
| public void setMailingLists( List<MailingList> mailingLists ) |
| { |
| getModel().setMailingLists( mailingLists ); |
| } |
| |
| public List<MailingList> getMailingLists() |
| { |
| return getModel().getMailingLists(); |
| } |
| |
| public void addMailingList( MailingList mailingList ) |
| { |
| getModel().addMailingList( mailingList ); |
| } |
| |
| public void setDevelopers( List<Developer> developers ) |
| { |
| getModel().setDevelopers( developers ); |
| } |
| |
| public List<Developer> getDevelopers() |
| { |
| return getModel().getDevelopers(); |
| } |
| |
| public void addDeveloper( Developer developer ) |
| { |
| getModel().addDeveloper( developer ); |
| } |
| |
| public void setContributors( List<Contributor> contributors ) |
| { |
| getModel().setContributors( contributors ); |
| } |
| |
| public List<Contributor> getContributors() |
| { |
| return getModel().getContributors(); |
| } |
| |
| public void addContributor( Contributor contributor ) |
| { |
| getModel().addContributor( contributor ); |
| } |
| |
| public void setBuild( Build build ) |
| { |
| getModel().setBuild( build ); |
| } |
| |
| public Build getBuild() |
| { |
| return getModelBuild(); |
| } |
| |
| public List<Resource> getResources() |
| { |
| return getBuild().getResources(); |
| } |
| |
| public List<Resource> getTestResources() |
| { |
| return getBuild().getTestResources(); |
| } |
| |
| public void addResource( Resource resource ) |
| { |
| getBuild().addResource( resource ); |
| } |
| |
| public void addTestResource( Resource testResource ) |
| { |
| getBuild().addTestResource( testResource ); |
| } |
| |
| public void setLicenses( List<License> licenses ) |
| { |
| getModel().setLicenses( licenses ); |
| } |
| |
| public List<License> getLicenses() |
| { |
| return getModel().getLicenses(); |
| } |
| |
| public void addLicense( License license ) |
| { |
| getModel().addLicense( license ); |
| } |
| |
| public void setArtifacts( Set<Artifact> artifacts ) |
| { |
| this.artifacts = artifacts; |
| |
| // flush the calculated artifactMap |
| artifactMap = null; |
| } |
| |
| /** |
| * All dependencies that this project has, including transitive ones. Contents are lazily populated, so depending on |
| * what phases have run dependencies in some scopes won't be included. eg. if only compile phase has run, |
| * dependencies with scope test won't be included. |
| * |
| * @return {@link Set} < {@link Artifact} > |
| * @see #getDependencyArtifacts() to get only direct dependencies |
| */ |
| public Set<Artifact> getArtifacts() |
| { |
| if ( artifacts == null ) |
| { |
| if ( artifactFilter == null || resolvedArtifacts == null ) |
| { |
| artifacts = new LinkedHashSet<>(); |
| } |
| else |
| { |
| artifacts = new LinkedHashSet<>( resolvedArtifacts.size() * 2 ); |
| for ( Artifact artifact : resolvedArtifacts ) |
| { |
| if ( artifactFilter.include( artifact ) ) |
| { |
| artifacts.add( artifact ); |
| } |
| } |
| } |
| } |
| return artifacts; |
| } |
| |
| public Map<String, Artifact> getArtifactMap() |
| { |
| if ( artifactMap == null ) |
| { |
| artifactMap = ArtifactUtils.artifactMapByVersionlessId( getArtifacts() ); |
| } |
| return artifactMap; |
| } |
| |
| public void setPluginArtifacts( Set<Artifact> pluginArtifacts ) |
| { |
| this.pluginArtifacts = pluginArtifacts; |
| |
| this.pluginArtifactMap = null; |
| } |
| |
| public Set<Artifact> getPluginArtifacts() |
| { |
| return pluginArtifacts; |
| } |
| |
| public Map<String, Artifact> getPluginArtifactMap() |
| { |
| if ( pluginArtifactMap == null ) |
| { |
| pluginArtifactMap = ArtifactUtils.artifactMapByVersionlessId( getPluginArtifacts() ); |
| } |
| |
| return pluginArtifactMap; |
| } |
| |
| public void setParentArtifact( Artifact parentArtifact ) |
| { |
| this.parentArtifact = parentArtifact; |
| } |
| |
| public Artifact getParentArtifact() |
| { |
| return parentArtifact; |
| } |
| |
| public List<Repository> getRepositories() |
| { |
| return getModel().getRepositories(); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Plugins |
| // ---------------------------------------------------------------------- |
| |
| public List<Plugin> getBuildPlugins() |
| { |
| if ( getModel().getBuild() == null ) |
| { |
| return Collections.emptyList(); |
| } |
| return Collections.unmodifiableList( getModel().getBuild().getPlugins() ); |
| } |
| |
| public List<String> getModules() |
| { |
| return getModel().getModules(); |
| } |
| |
| public PluginManagement getPluginManagement() |
| { |
| PluginManagement pluginMgmt = null; |
| |
| Build build = getModel().getBuild(); |
| if ( build != null ) |
| { |
| pluginMgmt = build.getPluginManagement(); |
| } |
| |
| return pluginMgmt; |
| } |
| |
| private Build getModelBuild() |
| { |
| Build build = getModel().getBuild(); |
| |
| if ( build == null ) |
| { |
| build = new Build(); |
| |
| getModel().setBuild( build ); |
| } |
| |
| return build; |
| } |
| |
| public void setRemoteArtifactRepositories( List<ArtifactRepository> remoteArtifactRepositories ) |
| { |
| this.remoteArtifactRepositories = remoteArtifactRepositories; |
| this.remoteProjectRepositories = RepositoryUtils.toRepos( getRemoteArtifactRepositories() ); |
| } |
| |
| public List<ArtifactRepository> getRemoteArtifactRepositories() |
| { |
| if ( remoteArtifactRepositories == null ) |
| { |
| remoteArtifactRepositories = new ArrayList<>(); |
| } |
| |
| return remoteArtifactRepositories; |
| } |
| |
| public void setPluginArtifactRepositories( List<ArtifactRepository> pluginArtifactRepositories ) |
| { |
| this.pluginArtifactRepositories = pluginArtifactRepositories; |
| this.remotePluginRepositories = RepositoryUtils.toRepos( getPluginArtifactRepositories() ); |
| } |
| |
| /** |
| * @return a list of ArtifactRepository objects constructed from the Repository objects returned by |
| * getPluginRepositories. |
| */ |
| public List<ArtifactRepository> getPluginArtifactRepositories() |
| { |
| if ( pluginArtifactRepositories == null ) |
| { |
| pluginArtifactRepositories = new ArrayList<>(); |
| } |
| |
| return pluginArtifactRepositories; |
| } |
| |
| public ArtifactRepository getDistributionManagementArtifactRepository() |
| { |
| return getArtifact().isSnapshot() && ( getSnapshotArtifactRepository() != null ) |
| ? getSnapshotArtifactRepository() |
| : getReleaseArtifactRepository(); |
| } |
| |
| public List<Repository> getPluginRepositories() |
| { |
| return getModel().getPluginRepositories(); |
| } |
| |
| public List<RemoteRepository> getRemoteProjectRepositories() |
| { |
| return remoteProjectRepositories; |
| } |
| |
| public List<RemoteRepository> getRemotePluginRepositories() |
| { |
| return remotePluginRepositories; |
| } |
| |
| public void setActiveProfiles( List<Profile> activeProfiles ) |
| { |
| this.activeProfiles = activeProfiles; |
| } |
| |
| public List<Profile> getActiveProfiles() |
| { |
| return activeProfiles; |
| } |
| |
| public void setInjectedProfileIds( String source, List<String> injectedProfileIds ) |
| { |
| if ( injectedProfileIds != null ) |
| { |
| this.injectedProfileIds.put( source, new ArrayList<>( injectedProfileIds ) ); |
| } |
| else |
| { |
| this.injectedProfileIds.remove( source ); |
| } |
| } |
| |
| /** |
| * Gets the identifiers of all profiles that contributed to this project's effective model. This includes active |
| * profiles from the project's POM and all its parent POMs as well as from external sources like the |
| * {@code settings.xml}. The profile identifiers are grouped by the identifier of their source, e.g. |
| * {@code <groupId>:<artifactId>:<version>} for a POM profile or {@code external} for profiles from the |
| * {@code settings.xml}. |
| * |
| * @return The identifiers of all injected profiles, indexed by the source from which the profiles originated, never |
| * {@code null}. |
| */ |
| public Map<String, List<String>> getInjectedProfileIds() |
| { |
| return this.injectedProfileIds; |
| } |
| |
| /** |
| * Add or replace an artifact. This method is now deprecated. Use the @{MavenProjectHelper} to attach artifacts to a |
| * project. In spite of the 'throws' declaration on this API, this method has never thrown an exception since Maven |
| * 3.0.x. Historically, it logged and ignored a second addition of the same g/a/v/c/t. Now it replaces the file for |
| * the artifact, so that plugins (e.g. shade) can change the pathname of the file for a particular set of |
| * coordinates. |
| * |
| * @param artifact the artifact to add or replace. |
| * @deprecated Please use {@link MavenProjectHelper} |
| * @throws DuplicateArtifactAttachmentException will never happen but leave it for backward compatibility |
| */ |
| public void addAttachedArtifact( Artifact artifact ) |
| throws DuplicateArtifactAttachmentException |
| { |
| // if already there we remove it and add again |
| int index = attachedArtifacts.indexOf( artifact ); |
| if ( index >= 0 ) |
| { |
| LOGGER.warn( "artifact '{}' already attached, replacing previous instance", artifact ); |
| attachedArtifacts.set( index, artifact ); |
| } |
| else |
| { |
| attachedArtifacts.add( artifact ); |
| } |
| } |
| |
| public List<Artifact> getAttachedArtifacts() |
| { |
| if ( attachedArtifacts == null ) |
| { |
| attachedArtifacts = new ArrayList<>(); |
| } |
| return Collections.unmodifiableList( attachedArtifacts ); |
| } |
| |
| public Xpp3Dom getGoalConfiguration( String pluginGroupId, String pluginArtifactId, String executionId, |
| String goalId ) |
| { |
| Xpp3Dom dom = null; |
| |
| if ( getBuildPlugins() != null ) |
| { |
| for ( Plugin plugin : getBuildPlugins() ) |
| { |
| if ( pluginGroupId.equals( plugin.getGroupId() ) && pluginArtifactId.equals( plugin.getArtifactId() ) ) |
| { |
| dom = (Xpp3Dom) plugin.getConfiguration(); |
| |
| if ( executionId != null ) |
| { |
| PluginExecution execution = plugin.getExecutionsAsMap().get( executionId ); |
| if ( execution != null ) |
| { |
| // NOTE: The PluginConfigurationExpander already merged the plugin-level config in |
| dom = (Xpp3Dom) execution.getConfiguration(); |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| if ( dom != null ) |
| { |
| // make a copy so the original in the POM doesn't get messed with |
| dom = new Xpp3Dom( dom ); |
| } |
| |
| return dom; |
| } |
| |
| public MavenProject getExecutionProject() |
| { |
| return ( executionProject == null ? this : executionProject ); |
| } |
| |
| public void setExecutionProject( MavenProject executionProject ) |
| { |
| this.executionProject = executionProject; |
| } |
| |
| public List<MavenProject> getCollectedProjects() |
| { |
| return collectedProjects; |
| } |
| |
| public void setCollectedProjects( List<MavenProject> collectedProjects ) |
| { |
| this.collectedProjects = collectedProjects; |
| } |
| |
| /** |
| * Direct dependencies that this project has. |
| * |
| * @return {@link Set} < {@link Artifact} > |
| * @see #getArtifacts() to get all transitive dependencies |
| */ |
| @Deprecated |
| public Set<Artifact> getDependencyArtifacts() |
| { |
| return dependencyArtifacts; |
| } |
| |
| @Deprecated |
| public void setDependencyArtifacts( Set<Artifact> dependencyArtifacts ) |
| { |
| this.dependencyArtifacts = dependencyArtifacts; |
| } |
| |
| public void setReleaseArtifactRepository( ArtifactRepository releaseArtifactRepository ) |
| { |
| this.releaseArtifactRepository = releaseArtifactRepository; |
| } |
| |
| public void setSnapshotArtifactRepository( ArtifactRepository snapshotArtifactRepository ) |
| { |
| this.snapshotArtifactRepository = snapshotArtifactRepository; |
| } |
| |
| public void setOriginalModel( Model originalModel ) |
| { |
| this.originalModel = originalModel; |
| } |
| |
| public Model getOriginalModel() |
| { |
| return originalModel; |
| } |
| |
| public void setManagedVersionMap( Map<String, Artifact> map ) |
| { |
| managedVersionMap = map; |
| } |
| |
| public Map<String, Artifact> getManagedVersionMap() |
| { |
| return managedVersionMap; |
| } |
| |
| @Override |
| public boolean equals( Object other ) |
| { |
| if ( other == this ) |
| { |
| return true; |
| } |
| else if ( !( other instanceof MavenProject ) ) |
| { |
| return false; |
| } |
| |
| MavenProject that = (MavenProject) other; |
| |
| return Objects.equals( getArtifactId(), that.getArtifactId() ) |
| && Objects.equals( getGroupId(), that.getGroupId() ) |
| && Objects.equals( getVersion(), that.getVersion() ); |
| } |
| |
| @Override |
| public int hashCode() |
| { |
| int hash = 17; |
| hash = 31 * hash + getGroupId().hashCode(); |
| hash = 31 * hash + getArtifactId().hashCode(); |
| hash = 31 * hash + getVersion().hashCode(); |
| return hash; |
| } |
| |
| public List<Extension> getBuildExtensions() |
| { |
| Build build = getBuild(); |
| if ( ( build == null ) || ( build.getExtensions() == null ) ) |
| { |
| return Collections.emptyList(); |
| } |
| else |
| { |
| return Collections.unmodifiableList( build.getExtensions() ); |
| } |
| } |
| |
| public void addProjectReference( MavenProject project ) |
| { |
| projectReferences.put( getProjectReferenceId( project.getGroupId(), project.getArtifactId(), |
| project.getVersion() ), project ); |
| } |
| |
| public Properties getProperties() |
| { |
| return getModel().getProperties(); |
| } |
| |
| public List<String> getFilters() |
| { |
| return getBuild().getFilters(); |
| } |
| |
| public Map<String, MavenProject> getProjectReferences() |
| { |
| return projectReferences; |
| } |
| |
| public boolean isExecutionRoot() |
| { |
| return executionRoot; |
| } |
| |
| public void setExecutionRoot( boolean executionRoot ) |
| { |
| this.executionRoot = executionRoot; |
| } |
| |
| public String getDefaultGoal() |
| { |
| return getBuild() != null ? getBuild().getDefaultGoal() : null; |
| } |
| |
| public Plugin getPlugin( String pluginKey ) |
| { |
| return getBuild().getPluginsAsMap().get( pluginKey ); |
| } |
| |
| /** |
| * Default toString |
| */ |
| @Override |
| public String toString() |
| { |
| StringBuilder sb = new StringBuilder( 128 ); |
| sb.append( "MavenProject: " ); |
| sb.append( getGroupId() ); |
| sb.append( ':' ); |
| sb.append( getArtifactId() ); |
| sb.append( ':' ); |
| sb.append( getVersion() ); |
| sb.append( " @ " ); |
| |
| try |
| { |
| sb.append( getFile().getPath() ); |
| } |
| catch ( NullPointerException e ) |
| { |
| // don't log it. |
| } |
| |
| return sb.toString(); |
| } |
| |
| /** |
| * @since 2.0.9 |
| */ |
| @Override |
| public MavenProject clone() |
| { |
| MavenProject clone; |
| try |
| { |
| clone = (MavenProject) super.clone(); |
| } |
| catch ( CloneNotSupportedException e ) |
| { |
| throw new UnsupportedOperationException( e ); |
| } |
| |
| clone.deepCopy( this ); |
| |
| return clone; |
| } |
| |
| public void setModel( Model model ) |
| { |
| this.model = model; |
| } |
| |
| protected void setAttachedArtifacts( List<Artifact> attachedArtifacts ) |
| { |
| this.attachedArtifacts = attachedArtifacts; |
| } |
| |
| protected void setCompileSourceRoots( List<String> compileSourceRoots ) |
| { |
| this.compileSourceRoots = compileSourceRoots; |
| } |
| |
| protected void setTestCompileSourceRoots( List<String> testCompileSourceRoots ) |
| { |
| this.testCompileSourceRoots = testCompileSourceRoots; |
| } |
| |
| protected ArtifactRepository getReleaseArtifactRepository() |
| { |
| return releaseArtifactRepository; |
| } |
| |
| protected ArtifactRepository getSnapshotArtifactRepository() |
| { |
| return snapshotArtifactRepository; |
| } |
| |
| private void deepCopy( MavenProject project ) |
| { |
| // disown the parent |
| |
| // copy fields |
| file = project.file; |
| basedir = project.basedir; |
| |
| // don't need a deep copy, they don't get modified or added/removed to/from - but make them unmodifiable to be |
| // sure! |
| if ( project.getDependencyArtifacts() != null ) |
| { |
| setDependencyArtifacts( Collections.unmodifiableSet( project.getDependencyArtifacts() ) ); |
| } |
| |
| if ( project.getArtifacts() != null ) |
| { |
| setArtifacts( Collections.unmodifiableSet( project.getArtifacts() ) ); |
| } |
| |
| if ( project.getParentFile() != null ) |
| { |
| parentFile = new File( project.getParentFile().getAbsolutePath() ); |
| } |
| |
| if ( project.getPluginArtifacts() != null ) |
| { |
| setPluginArtifacts( Collections.unmodifiableSet( project.getPluginArtifacts() ) ); |
| } |
| |
| if ( project.getReportArtifacts() != null ) |
| { |
| setReportArtifacts( Collections.unmodifiableSet( project.getReportArtifacts() ) ); |
| } |
| |
| if ( project.getExtensionArtifacts() != null ) |
| { |
| setExtensionArtifacts( Collections.unmodifiableSet( project.getExtensionArtifacts() ) ); |
| } |
| |
| setParentArtifact( ( project.getParentArtifact() ) ); |
| |
| if ( project.getRemoteArtifactRepositories() != null ) |
| { |
| setRemoteArtifactRepositories( Collections.unmodifiableList( project.getRemoteArtifactRepositories() ) ); |
| } |
| |
| if ( project.getPluginArtifactRepositories() != null ) |
| { |
| setPluginArtifactRepositories( Collections.unmodifiableList( project.getPluginArtifactRepositories() ) ); |
| } |
| |
| if ( project.getActiveProfiles() != null ) |
| { |
| setActiveProfiles( ( Collections.unmodifiableList( project.getActiveProfiles() ) ) ); |
| } |
| |
| if ( project.getAttachedArtifacts() != null ) |
| { |
| // clone properties modifyable by plugins in a forked lifecycle |
| setAttachedArtifacts( new ArrayList<>( project.getAttachedArtifacts() ) ); |
| } |
| |
| if ( project.getCompileSourceRoots() != null ) |
| { |
| // clone source roots |
| setCompileSourceRoots( ( new ArrayList<>( project.getCompileSourceRoots() ) ) ); |
| } |
| |
| if ( project.getTestCompileSourceRoots() != null ) |
| { |
| setTestCompileSourceRoots( ( new ArrayList<>( project.getTestCompileSourceRoots() ) ) ); |
| } |
| |
| if ( project.getScriptSourceRoots() != null ) |
| { |
| setScriptSourceRoots( ( new ArrayList<>( project.getScriptSourceRoots() ) ) ); |
| } |
| |
| if ( project.getModel() != null ) |
| { |
| setModel( project.getModel().clone() ); |
| } |
| |
| if ( project.getOriginalModel() != null ) |
| { |
| setOriginalModel( project.getOriginalModel() ); |
| } |
| |
| setExecutionRoot( project.isExecutionRoot() ); |
| |
| if ( project.getArtifact() != null ) |
| { |
| setArtifact( ArtifactUtils.copyArtifact( project.getArtifact() ) ); |
| } |
| |
| if ( project.getManagedVersionMap() != null ) |
| { |
| setManagedVersionMap( project.getManagedVersionMap() ); |
| } |
| |
| lifecyclePhases.addAll( project.lifecyclePhases ); |
| } |
| |
| private void addArtifactPath( Artifact artifact, List<String> classpath ) |
| { |
| File file = artifact.getFile(); |
| if ( file != null ) |
| { |
| classpath.add( file.getPath() ); |
| } |
| } |
| |
| private static String getProjectReferenceId( String groupId, String artifactId, String version ) |
| { |
| StringBuilder buffer = new StringBuilder( 128 ); |
| buffer.append( groupId ).append( ':' ).append( artifactId ).append( ':' ).append( version ); |
| return buffer.toString(); |
| } |
| |
| /** |
| * Sets the value of the context value of this project identified by the given key. If the supplied value is |
| * <code>null</code>, the context value is removed from this project. Context values are intended to allow core |
| * extensions to associate derived state with project instances. |
| */ |
| public void setContextValue( String key, Object value ) |
| { |
| if ( context == null ) |
| { |
| context = new HashMap<>(); |
| } |
| if ( value != null ) |
| { |
| context.put( key, value ); |
| } |
| else |
| { |
| context.remove( key ); |
| } |
| } |
| |
| /** |
| * Returns context value of this project associated with the given key or null if this project has no such value. |
| */ |
| public Object getContextValue( String key ) |
| { |
| if ( context == null ) |
| { |
| return null; |
| } |
| return context.get( key ); |
| } |
| |
| /** |
| * Sets the project's class realm. <strong>Warning:</strong> This is an internal utility method that is only public |
| * for technical reasons, it is not part of the public API. In particular, this method can be changed or deleted |
| * without prior notice and must not be used by plugins. |
| * |
| * @param classRealm The class realm hosting the build extensions of this project, may be {@code null}. |
| */ |
| public void setClassRealm( ClassRealm classRealm ) |
| { |
| this.classRealm = classRealm; |
| } |
| |
| /** |
| * Gets the project's class realm. This class realm hosts the build extensions of the project. |
| * <strong>Warning:</strong> This is an internal utility method that is only public for technical reasons, it is not |
| * part of the public API. In particular, this method can be changed or deleted without prior notice and must not be |
| * used by plugins. |
| * |
| * @return The project's class realm or {@code null}. |
| */ |
| public ClassRealm getClassRealm() |
| { |
| return classRealm; |
| } |
| |
| /** |
| * Sets the artifact filter used to exclude shared extension artifacts from plugin realms. <strong>Warning:</strong> |
| * This is an internal utility method that is only public for technical reasons, it is not part of the public API. |
| * In particular, this method can be changed or deleted without prior notice and must not be used by plugins. |
| * |
| * @param extensionDependencyFilter The dependency filter to apply to plugins, may be {@code null}. |
| */ |
| public void setExtensionDependencyFilter( DependencyFilter extensionDependencyFilter ) |
| { |
| this.extensionDependencyFilter = extensionDependencyFilter; |
| } |
| |
| /** |
| * Gets the dependency filter used to exclude shared extension artifacts from plugin realms. |
| * <strong>Warning:</strong> This is an internal utility method that is only public for technical reasons, it is not |
| * part of the public API. In particular, this method can be changed or deleted without prior notice and must not be |
| * used by plugins. |
| * |
| * @return The dependency filter or {@code null}. |
| */ |
| public DependencyFilter getExtensionDependencyFilter() |
| { |
| return extensionDependencyFilter; |
| } |
| |
| /** |
| * Sets the transitive dependency artifacts that have been resolved/collected for this project. |
| * <strong>Warning:</strong> This is an internal utility method that is only public for technical reasons, it is not |
| * part of the public API. In particular, this method can be changed or deleted without prior notice and must not be |
| * used by plugins. |
| * |
| * @param artifacts The set of artifacts, may be {@code null}. |
| */ |
| public void setResolvedArtifacts( Set<Artifact> artifacts ) |
| { |
| this.resolvedArtifacts = ( artifacts != null ) ? artifacts : Collections.<Artifact>emptySet(); |
| this.artifacts = null; |
| this.artifactMap = null; |
| } |
| |
| /** |
| * Sets the scope filter to select the artifacts being exposed to the currently executed mojo. |
| * <strong>Warning:</strong> This is an internal utility method that is only public for technical reasons, it is not |
| * part of the public API. In particular, this method can be changed or deleted without prior notice and must not be |
| * used by plugins. |
| * |
| * @param artifactFilter The artifact filter, may be {@code null} to exclude all artifacts. |
| */ |
| public void setArtifactFilter( ArtifactFilter artifactFilter ) |
| { |
| this.artifactFilter = artifactFilter; |
| this.artifacts = null; |
| this.artifactMap = null; |
| } |
| |
| /** |
| * <strong>Warning:</strong> This is an internal utility method that is only public for technical reasons, it is not |
| * part of the public API. In particular, this method can be changed or deleted without prior notice and must not be |
| * used by plugins. |
| * |
| * @param phase The phase to check for, must not be {@code null}. |
| * @return {@code true} if the phase has been seen. |
| */ |
| public boolean hasLifecyclePhase( String phase ) |
| { |
| return lifecyclePhases.contains( phase ); |
| } |
| |
| /** |
| * <strong>Warning:</strong> This is an internal utility method that is only public for technical reasons, it is not |
| * part of the public API. In particular, this method can be changed or deleted without prior notice and must not be |
| * used by plugins. |
| * |
| * @param lifecyclePhase The lifecycle phase to add, must not be {@code null}. |
| */ |
| public void addLifecyclePhase( String lifecyclePhase ) |
| { |
| lifecyclePhases.add( lifecyclePhase ); |
| } |
| |
| // ---------------------------------------------------------------------------------------------------------------- |
| // |
| // |
| // D E P R E C A T E D |
| // |
| // |
| // ---------------------------------------------------------------------------------------------------------------- |
| // |
| // Everything below will be removed for Maven 4.0.0 |
| // |
| // ---------------------------------------------------------------------------------------------------------------- |
| |
| private ProjectBuildingRequest projectBuilderConfiguration; |
| |
| private Map<String, String> moduleAdjustments; |
| |
| @Deprecated // This appears only to be used in test code |
| public String getModulePathAdjustment( MavenProject moduleProject ) |
| throws IOException |
| { |
| // FIXME: This is hacky. What if module directory doesn't match artifactid, and parent |
| // is coming from the repository?? |
| String module = moduleProject.getArtifactId(); |
| |
| File moduleFile = moduleProject.getFile(); |
| |
| if ( moduleFile != null ) |
| { |
| File moduleDir = moduleFile.getCanonicalFile().getParentFile(); |
| |
| module = moduleDir.getName(); |
| } |
| |
| if ( moduleAdjustments == null ) |
| { |
| moduleAdjustments = new HashMap<>(); |
| |
| List<String> modules = getModules(); |
| if ( modules != null ) |
| { |
| for ( String modulePath : modules ) |
| { |
| String moduleName = modulePath; |
| |
| if ( moduleName.endsWith( "/" ) || moduleName.endsWith( "\\" ) ) |
| { |
| moduleName = moduleName.substring( 0, moduleName.length() - 1 ); |
| } |
| |
| int lastSlash = moduleName.lastIndexOf( '/' ); |
| |
| if ( lastSlash < 0 ) |
| { |
| lastSlash = moduleName.lastIndexOf( '\\' ); |
| } |
| |
| String adjustment = null; |
| |
| if ( lastSlash > -1 ) |
| { |
| moduleName = moduleName.substring( lastSlash + 1 ); |
| adjustment = modulePath.substring( 0, lastSlash ); |
| } |
| |
| moduleAdjustments.put( moduleName, adjustment ); |
| } |
| } |
| } |
| |
| return moduleAdjustments.get( module ); |
| } |
| |
| @Deprecated |
| public Set<Artifact> createArtifacts( ArtifactFactory artifactFactory, String inheritedScope, |
| ArtifactFilter filter ) |
| throws InvalidDependencyVersionException |
| { |
| return MavenMetadataSource.createArtifacts( artifactFactory, getDependencies(), inheritedScope, filter, this ); |
| } |
| |
| @Deprecated |
| protected void setScriptSourceRoots( List<String> scriptSourceRoots ) |
| { |
| this.scriptSourceRoots = scriptSourceRoots; |
| } |
| |
| @Deprecated |
| public void addScriptSourceRoot( String path ) |
| { |
| if ( path != null ) |
| { |
| path = path.trim(); |
| if ( path.length() != 0 ) |
| { |
| if ( !getScriptSourceRoots().contains( path ) ) |
| { |
| getScriptSourceRoots().add( path ); |
| } |
| } |
| } |
| } |
| |
| @Deprecated |
| public List<String> getScriptSourceRoots() |
| { |
| return scriptSourceRoots; |
| } |
| |
| @Deprecated |
| public List<Artifact> getCompileArtifacts() |
| { |
| List<Artifact> list = new ArrayList<>( getArtifacts().size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO classpath check doesn't belong here - that's the other method |
| if ( a.getArtifactHandler().isAddedToClasspath() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_COMPILE.equals( a.getScope() ) || Artifact.SCOPE_PROVIDED.equals( a.getScope() ) |
| || Artifact.SCOPE_SYSTEM.equals( a.getScope() ) ) |
| { |
| list.add( a ); |
| } |
| } |
| } |
| return list; |
| } |
| |
| @Deprecated |
| public List<Dependency> getCompileDependencies() |
| { |
| Set<Artifact> artifacts = getArtifacts(); |
| |
| if ( ( artifacts == null ) || artifacts.isEmpty() ) |
| { |
| return Collections.emptyList(); |
| } |
| |
| List<Dependency> list = new ArrayList<>( artifacts.size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_COMPILE.equals( a.getScope() ) || Artifact.SCOPE_PROVIDED.equals( a.getScope() ) |
| || Artifact.SCOPE_SYSTEM.equals( a.getScope() ) ) |
| { |
| Dependency dependency = new Dependency(); |
| |
| dependency.setArtifactId( a.getArtifactId() ); |
| dependency.setGroupId( a.getGroupId() ); |
| dependency.setVersion( a.getVersion() ); |
| dependency.setScope( a.getScope() ); |
| dependency.setType( a.getType() ); |
| dependency.setClassifier( a.getClassifier() ); |
| |
| list.add( dependency ); |
| } |
| } |
| return Collections.unmodifiableList( list ); |
| } |
| |
| @Deprecated |
| public List<Artifact> getTestArtifacts() |
| { |
| List<Artifact> list = new ArrayList<>( getArtifacts().size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO classpath check doesn't belong here - that's the other method |
| if ( a.getArtifactHandler().isAddedToClasspath() ) |
| { |
| list.add( a ); |
| } |
| } |
| return list; |
| } |
| |
| @Deprecated |
| public List<Dependency> getTestDependencies() |
| { |
| Set<Artifact> artifacts = getArtifacts(); |
| |
| if ( ( artifacts == null ) || artifacts.isEmpty() ) |
| { |
| return Collections.emptyList(); |
| } |
| |
| List<Dependency> list = new ArrayList<>( artifacts.size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| Dependency dependency = new Dependency(); |
| |
| dependency.setArtifactId( a.getArtifactId() ); |
| dependency.setGroupId( a.getGroupId() ); |
| dependency.setVersion( a.getVersion() ); |
| dependency.setScope( a.getScope() ); |
| dependency.setType( a.getType() ); |
| dependency.setClassifier( a.getClassifier() ); |
| |
| list.add( dependency ); |
| } |
| return Collections.unmodifiableList( list ); |
| } |
| |
| @Deprecated // used by the Maven ITs |
| public List<Dependency> getRuntimeDependencies() |
| { |
| Set<Artifact> artifacts = getArtifacts(); |
| |
| if ( ( artifacts == null ) || artifacts.isEmpty() ) |
| { |
| return Collections.emptyList(); |
| } |
| |
| List<Dependency> list = new ArrayList<>( artifacts.size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_COMPILE.equals( a.getScope() ) || Artifact.SCOPE_RUNTIME.equals( a.getScope() ) ) |
| { |
| Dependency dependency = new Dependency(); |
| |
| dependency.setArtifactId( a.getArtifactId() ); |
| dependency.setGroupId( a.getGroupId() ); |
| dependency.setVersion( a.getVersion() ); |
| dependency.setScope( a.getScope() ); |
| dependency.setType( a.getType() ); |
| dependency.setClassifier( a.getClassifier() ); |
| |
| list.add( dependency ); |
| } |
| } |
| return Collections.unmodifiableList( list ); |
| } |
| |
| @Deprecated |
| public List<Artifact> getRuntimeArtifacts() |
| { |
| List<Artifact> list = new ArrayList<>( getArtifacts().size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO classpath check doesn't belong here - that's the other method |
| if ( a.getArtifactHandler().isAddedToClasspath() |
| // TODO let the scope handler deal with this |
| && ( Artifact.SCOPE_COMPILE.equals( a.getScope() ) || Artifact.SCOPE_RUNTIME.equals( a.getScope() ) ) ) |
| { |
| list.add( a ); |
| } |
| } |
| return list; |
| } |
| |
| @Deprecated |
| public List<String> getSystemClasspathElements() |
| throws DependencyResolutionRequiredException |
| { |
| List<String> list = new ArrayList<>( getArtifacts().size() ); |
| |
| String d = getBuild().getOutputDirectory(); |
| if ( d != null ) |
| { |
| list.add( d ); |
| } |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| if ( a.getArtifactHandler().isAddedToClasspath() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_SYSTEM.equals( a.getScope() ) ) |
| { |
| addArtifactPath( a, list ); |
| } |
| } |
| } |
| return list; |
| } |
| |
| @Deprecated |
| public List<Artifact> getSystemArtifacts() |
| { |
| List<Artifact> list = new ArrayList<>( getArtifacts().size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO classpath check doesn't belong here - that's the other method |
| if ( a.getArtifactHandler().isAddedToClasspath() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_SYSTEM.equals( a.getScope() ) ) |
| { |
| list.add( a ); |
| } |
| } |
| } |
| return list; |
| } |
| |
| @Deprecated |
| public List<Dependency> getSystemDependencies() |
| { |
| Set<Artifact> artifacts = getArtifacts(); |
| |
| if ( ( artifacts == null ) || artifacts.isEmpty() ) |
| { |
| return Collections.emptyList(); |
| } |
| |
| List<Dependency> list = new ArrayList<>( artifacts.size() ); |
| |
| for ( Artifact a : getArtifacts() ) |
| { |
| // TODO let the scope handler deal with this |
| if ( Artifact.SCOPE_SYSTEM.equals( a.getScope() ) ) |
| { |
| Dependency dependency = new Dependency(); |
| |
| dependency.setArtifactId( a.getArtifactId() ); |
| dependency.setGroupId( a.getGroupId() ); |
| dependency.setVersion( a.getVersion() ); |
| dependency.setScope( a.getScope() ); |
| dependency.setType( a.getType() ); |
| dependency.setClassifier( a.getClassifier() ); |
| |
| list.add( dependency ); |
| } |
| } |
| return Collections.unmodifiableList( list ); |
| } |
| |
| @Deprecated |
| public void setReporting( Reporting reporting ) |
| { |
| getModel().setReporting( reporting ); |
| } |
| |
| @Deprecated |
| public Reporting getReporting() |
| { |
| return getModel().getReporting(); |
| } |
| |
| @Deprecated |
| public void setReportArtifacts( Set<Artifact> reportArtifacts ) |
| { |
| this.reportArtifacts = reportArtifacts; |
| |
| reportArtifactMap = null; |
| } |
| |
| @Deprecated |
| public Set<Artifact> getReportArtifacts() |
| { |
| return reportArtifacts; |
| } |
| |
| @Deprecated |
| public Map<String, Artifact> getReportArtifactMap() |
| { |
| if ( reportArtifactMap == null ) |
| { |
| reportArtifactMap = ArtifactUtils.artifactMapByVersionlessId( getReportArtifacts() ); |
| } |
| |
| return reportArtifactMap; |
| } |
| |
| @Deprecated |
| public void setExtensionArtifacts( Set<Artifact> extensionArtifacts ) |
| { |
| this.extensionArtifacts = extensionArtifacts; |
| |
| extensionArtifactMap = null; |
| } |
| |
| @Deprecated |
| public Set<Artifact> getExtensionArtifacts() |
| { |
| return extensionArtifacts; |
| } |
| |
| @Deprecated |
| public Map<String, Artifact> getExtensionArtifactMap() |
| { |
| if ( extensionArtifactMap == null ) |
| { |
| extensionArtifactMap = ArtifactUtils.artifactMapByVersionlessId( getExtensionArtifacts() ); |
| } |
| |
| return extensionArtifactMap; |
| } |
| |
| @Deprecated |
| public List<ReportPlugin> getReportPlugins() |
| { |
| if ( getModel().getReporting() == null ) |
| { |
| return Collections.emptyList(); |
| } |
| return Collections.unmodifiableList( getModel().getReporting().getPlugins() ); |
| } |
| |
| @Deprecated |
| public Xpp3Dom getReportConfiguration( String pluginGroupId, String pluginArtifactId, String reportSetId ) |
| { |
| Xpp3Dom dom = null; |
| |
| // ---------------------------------------------------------------------- |
| // I would like to be able to lookup the Mojo object using a key but |
| // we have a limitation in modello that will be remedied shortly. So |
| // for now I have to iterate through and see what we have. |
| // ---------------------------------------------------------------------- |
| |
| if ( getReportPlugins() != null ) |
| { |
| for ( ReportPlugin plugin : getReportPlugins() ) |
| { |
| if ( pluginGroupId.equals( plugin.getGroupId() ) && pluginArtifactId.equals( plugin.getArtifactId() ) ) |
| { |
| dom = (Xpp3Dom) plugin.getConfiguration(); |
| |
| if ( reportSetId != null ) |
| { |
| ReportSet reportSet = plugin.getReportSetsAsMap().get( reportSetId ); |
| if ( reportSet != null ) |
| { |
| Xpp3Dom executionConfiguration = (Xpp3Dom) reportSet.getConfiguration(); |
| if ( executionConfiguration != null ) |
| { |
| Xpp3Dom newDom = new Xpp3Dom( executionConfiguration ); |
| dom = Xpp3Dom.mergeXpp3Dom( newDom, dom ); |
| } |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| if ( dom != null ) |
| { |
| // make a copy so the original in the POM doesn't get messed with |
| dom = new Xpp3Dom( dom ); |
| } |
| |
| return dom; |
| } |
| |
| /** |
| * @deprecated Use MavenProjectHelper.attachArtifact(..) instead. |
| */ |
| @Deprecated |
| public void attachArtifact( String type, String classifier, File file ) |
| { |
| } |
| |
| /** |
| * @deprecated Use {@link org.apache.maven.model.io.ModelWriter}. |
| */ |
| @Deprecated |
| public void writeModel( Writer writer ) |
| throws IOException |
| { |
| MavenXpp3Writer pomWriter = new MavenXpp3Writer(); |
| pomWriter.write( writer, getModel() ); |
| } |
| |
| /** |
| * @deprecated Use {@link org.apache.maven.model.io.ModelWriter}. |
| */ |
| @Deprecated |
| public void writeOriginalModel( Writer writer ) |
| throws IOException |
| { |
| MavenXpp3Writer pomWriter = new MavenXpp3Writer(); |
| pomWriter.write( writer, getOriginalModel() ); |
| } |
| |
| @Deprecated |
| public Artifact replaceWithActiveArtifact( Artifact pluginArtifact ) |
| { |
| return pluginArtifact; |
| } |
| |
| /** |
| * Gets the project building request from which this project instance was created. <strong>Warning:</strong> This is |
| * an utility method that is meant to assist integrators of Maven, it must not be used by Maven plugins. |
| * |
| * @return The project building request or {@code null}. |
| * @since 2.1 |
| */ |
| @Deprecated |
| public ProjectBuildingRequest getProjectBuildingRequest() |
| { |
| return projectBuilderConfiguration; |
| } |
| |
| /** |
| * Sets the project building request from which this project instance was created. <strong>Warning:</strong> This is |
| * an utility method that is meant to assist integrators of Maven, it must not be used by Maven plugins. |
| * |
| * @param projectBuildingRequest The project building request, may be {@code null}. |
| * @since 2.1 |
| */ |
| // used by maven-dependency-tree |
| @Deprecated |
| public void setProjectBuildingRequest( ProjectBuildingRequest projectBuildingRequest ) |
| { |
| this.projectBuilderConfiguration = projectBuildingRequest; |
| } |
| } |
