Coverage Report

Coverage Report - org.apache.maven.plugin.assembly.artifact.DefaultDependencyResolver

Classes in this File

Line Coverage

Branch Coverage

Complexity

DefaultDependencyResolver

47%

70/146

58%

41/70

3,474

 package org.apache.maven.plugin.assembly.artifact;
 
 /*
  * 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.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.factory.ArtifactFactory;
 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.artifact.resolver.ArtifactCollector;
 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
 import org.apache.maven.artifact.resolver.ArtifactResolutionException;
 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
 import org.apache.maven.artifact.resolver.ArtifactResolver;
 import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException;
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
 import org.apache.maven.plugin.assembly.AssemblerConfigurationSource;
 import org.apache.maven.plugin.assembly.AssemblyContext;
 import org.apache.maven.plugin.assembly.archive.ArchiveCreationException;
 import org.apache.maven.plugin.assembly.archive.phase.ModuleSetAssemblyPhase;
 import org.apache.maven.plugin.assembly.model.Assembly;
 import org.apache.maven.plugin.assembly.model.DependencySet;
 import org.apache.maven.plugin.assembly.model.ModuleBinaries;
 import org.apache.maven.plugin.assembly.model.ModuleSet;
 import org.apache.maven.plugin.assembly.model.Repository;
 import org.apache.maven.plugin.assembly.utils.FilterUtils;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.project.artifact.InvalidDependencyVersionException;
 import org.codehaus.plexus.component.annotations.Component;
 import org.codehaus.plexus.component.annotations.Requirement;
 import org.codehaus.plexus.logging.AbstractLogEnabled;
 import org.codehaus.plexus.logging.Logger;
 import org.codehaus.plexus.util.StringUtils;
 
 /**
  * @author jdcasey
  * @version $Id: DefaultDependencyResolver.java 1163853 2011-08-31 22:42:32Z jdcasey $
  */
 @Component( role = DependencyResolver.class )
 public class DefaultDependencyResolver
     extends AbstractLogEnabled
     implements DependencyResolver
 {
 
     @Requirement
     private ArtifactResolver resolver;
 
     @Requirement
     private ArtifactMetadataSource metadataSource;
 
     @Requirement
     private ArtifactFactory factory;
 
     @Requirement
     private ArtifactCollector collector;
 
     public DefaultDependencyResolver()
     {
         // for plexus init
     }
 
     protected DefaultDependencyResolver( final ArtifactResolver resolver, final ArtifactMetadataSource metadataSource,
                                          final ArtifactFactory factory, final ArtifactCollector collector,
                                          final Logger logger )
     {
         this.resolver = resolver;
         this.metadataSource = metadataSource;
         this.factory = factory;
         this.collector = collector;
 
         enableLogging( logger );
     }
 
     public void resolve( final Assembly assembly, final AssemblerConfigurationSource configSource,
                          final AssemblyContext context )
         throws DependencyResolutionException
     {
         final MavenProject currentProject = configSource.getProject();
 
         final ResolutionManagementInfo info = new ResolutionManagementInfo( currentProject );
         getRepositoryResolutionRequirements( assembly, info, currentProject );
         getDependencySetResolutionRequirements( assembly, assembly.getDependencySets(), info, currentProject );
         getModuleSetResolutionRequirements( assembly, info, configSource );
 
         if ( !info.isResolutionRequired() )
         {
             context.setResolvedArtifacts( new HashSet<Artifact>() );
             return;
         }
 
         final List<ArtifactRepository> repos =
             aggregateRemoteArtifactRepositories( configSource.getRemoteRepositories(), info.getEnabledProjects() );
 
         Set<Artifact> artifacts = info.getArtifacts();
         if ( info.isResolvedTransitively() )
         {
             getLogger().debug( "Resolving project dependencies transitively." );
             artifacts = resolveTransitively( artifacts, repos, info, configSource );
         }
         else
         {
             getLogger().debug( "Resolving project dependencies ONLY. Transitive dependencies WILL NOT be included in the results." );
             artifacts = resolveNonTransitively( assembly, artifacts, configSource, repos );
         }
 
         context.setResolvedArtifacts( artifacts );
     }
 
     protected Set<Artifact> resolveNonTransitively( final Assembly assembly, final Set<Artifact> dependencyArtifacts,
                                                     final AssemblerConfigurationSource configSource,
                                                     final List<ArtifactRepository> repos )
         throws DependencyResolutionException
     {
 
         final List<Artifact> missing = new ArrayList<Artifact>();
         final Set<Artifact> resolved = new LinkedHashSet<Artifact>();
         for ( final Iterator<Artifact> it = dependencyArtifacts.iterator(); it.hasNext(); )
         {
             final Artifact depArtifact = it.next();
 
             try
             {
                 resolver.resolve( depArtifact, repos, configSource.getLocalRepository() );
                 resolved.add( depArtifact );
             }
             catch ( final ArtifactResolutionException e )
             {
                 if ( getLogger().isDebugEnabled() )
                 {
                     getLogger().debug( "Failed to resolve: " + depArtifact.getId() + " for assembly: "
                                            + assembly.getId() );
                 }
                 missing.add( depArtifact );
             }
             catch ( final ArtifactNotFoundException e )
             {
                 if ( getLogger().isDebugEnabled() )
                 {
                     getLogger().debug( "Failed to resolve: " + depArtifact.getId() + " for assembly: "
                                            + assembly.getId() );
                 }
                 missing.add( depArtifact );
             }
         }
 
         if ( !missing.isEmpty() )
         {
             final MavenProject project = configSource.getProject();
             final Artifact rootArtifact = project.getArtifact();
 
             final Throwable error =
                 new MultipleArtifactsNotFoundException( rootArtifact, new ArrayList<Artifact>( resolved ), missing,
                                                         repos );
 
             throw new DependencyResolutionException( "Failed to resolve dependencies for: " + assembly.getId(), error );
         }
 
         return resolved;
     }
 
     @SuppressWarnings( "unchecked" )
     private Set<Artifact> resolveTransitively( final Set<Artifact> dependencyArtifacts,
                                                final List<ArtifactRepository> repos,
                                                final ResolutionManagementInfo info,
                                                final AssemblerConfigurationSource configSource )
         throws DependencyResolutionException
     {
         final MavenProject project = configSource.getProject();
 
         final ArtifactFilter filter = info.getScopeFilter();
         final ArtifactRepository localRepository = configSource.getLocalRepository();
 
         ArtifactResolutionResult result;
         try
         {
             result =
                 resolver.resolveTransitively( dependencyArtifacts, project.getArtifact(),
                                               project.getManagedVersionMap(), localRepository, repos, metadataSource,
                                               filter );
         }
         catch ( final ArtifactResolutionException e )
         {
             throw new DependencyResolutionException( "Failed to resolve dependencies for assembly: ", e );
         }
         catch ( final ArtifactNotFoundException e )
         {
             throw new DependencyResolutionException( "Failed to resolve dependencies for assembly: ", e );
         }
 
         getLogger().debug( "While resolving dependencies of " + project.getId() + ":" );
 
         FilterUtils.reportFilteringStatistics( Collections.singleton( filter ), getLogger() );
 
         return result.getArtifacts();
     }
 
     protected void getRepositoryResolutionRequirements( final Assembly assembly,
                                                         final ResolutionManagementInfo requirements,
                                                         final MavenProject... project )
     {
         final List<Repository> repositories = assembly.getRepositories();
 
         if ( repositories != null && !repositories.isEmpty() )
         {
             requirements.setResolutionRequired( true );
             for ( final Repository repo : repositories )
             {
                 enableScope( repo.getScope(), requirements );
             }
         }
     }
 
     protected void getModuleSetResolutionRequirements( final Assembly assembly,
                                                        final ResolutionManagementInfo requirements,
                                                        final AssemblerConfigurationSource configSource )
         throws DependencyResolutionException
     {
         final List<ModuleSet> moduleSets = assembly.getModuleSets();
 
         if ( moduleSets != null && !moduleSets.isEmpty() )
         {
             for ( final ModuleSet set : moduleSets )
             {
                 final ModuleBinaries binaries = set.getBinaries();
                 if ( binaries != null )
                 {
                     Set<MavenProject> projects;
                     try
                     {
                         projects = ModuleSetAssemblyPhase.getModuleProjects( set, configSource, getLogger() );
                     }
                     catch ( final ArchiveCreationException e )
                     {
                         throw new DependencyResolutionException(
                                                                  "Error determining project-set for moduleSet with binaries.",
                                                                  e );
                     }
 
                     if ( projects != null && !projects.isEmpty() )
                     {
                         for ( final MavenProject p : projects )
                         {
                             requirements.enableProjectResolution( p );
 
                             if ( p.getArtifact() == null )
                             {
                                 // TODO: such a call in MavenMetadataSource too - packaging not really the intention of
                                 // type
                                 final Artifact artifact =
                                     factory.createBuildArtifact( p.getGroupId(), p.getArtifactId(), p.getVersion(),
                                                                  p.getPackaging() );
                                 p.setArtifact( artifact );
                             }
                         }
                     }
 
                     if ( binaries.isIncludeDependencies() )
                     {
                         getDependencySetResolutionRequirements( assembly,
                                                                 ModuleSetAssemblyPhase.getDependencySets( binaries ),
                                                                 requirements, projects.toArray( new MavenProject[] {} ) );
                     }
                 }
             }
         }
     }
 
     @SuppressWarnings( "unchecked" )
     protected void getDependencySetResolutionRequirements( final Assembly assembly, final List<DependencySet> depSets,
                                                            final ResolutionManagementInfo requirements,
                                                            final MavenProject... projects )
         throws DependencyResolutionException
     {
         if ( depSets != null && !depSets.isEmpty() )
         {
             requirements.setResolutionRequired( true );
 
             for ( final DependencySet set : depSets )
             {
                 requirements.setResolvedTransitively( set.isUseTransitiveDependencies() );
 
                 enableScope( set.getScope(), requirements );
             }
 
             for ( final MavenProject project : projects )
             {
                 if ( project == null )
                 {
                     continue;
                 }
 
                 Set<Artifact> dependencyArtifacts = project.getDependencyArtifacts();
                 if ( dependencyArtifacts == null )
                 {
                     try
                     {
                         dependencyArtifacts = project.createArtifacts( factory, null, requirements.getScopeFilter() );
                         project.setDependencyArtifacts( dependencyArtifacts );
                     }
                     catch ( final InvalidDependencyVersionException e )
                     {
                         throw new DependencyResolutionException(
                                                                  "Failed to create dependency artifacts for resolution. Assembly: "
                                                                      + assembly.getId(), e );
                     }
                 }
 
                 requirements.addArtifacts( dependencyArtifacts );
                 getLogger().debug( "Dependencies for project: " + project.getId() + " are:\n"
                                        + StringUtils.join( dependencyArtifacts.iterator(), "\n" ) );
             }
         }
     }
 
     private void enableScope( final String scope, final ResolutionManagementInfo requirements )
     {
         if ( Artifact.SCOPE_COMPILE.equals( scope ) )
         {
             requirements.enableCompileScope();
         }
         else if ( Artifact.SCOPE_PROVIDED.equals( scope ) )
         {
             requirements.enableProvidedScope();
         }
         else if ( Artifact.SCOPE_RUNTIME.equals( scope ) )
         {
             requirements.enableRuntimeScope();
         }
         else if ( Artifact.SCOPE_SYSTEM.equals( scope ) )
         {
             requirements.enableSystemScope();
         }
         else if ( Artifact.SCOPE_TEST.equals( scope ) )
         {
             requirements.enableTestScope();
         }
     }
 
     @SuppressWarnings( "unchecked" )
     protected List<ArtifactRepository> aggregateRemoteArtifactRepositories( final List<ArtifactRepository> remoteRepositories,
                                                                             final Set<MavenProject> projects )
     {
         final List<List<ArtifactRepository>> repoLists = new ArrayList<List<ArtifactRepository>>();
 
         repoLists.add( remoteRepositories );
         for ( final MavenProject project : projects )
         {
             repoLists.add( project.getRemoteArtifactRepositories() );
         }
 
         final List<ArtifactRepository> remoteRepos = new ArrayList<ArtifactRepository>();
         final Set<String> encounteredUrls = new HashSet<String>();
 
         for ( final Iterator<List<ArtifactRepository>> listIterator = repoLists.iterator(); listIterator.hasNext(); )
         {
             final List<ArtifactRepository> repositoryList = listIterator.next();
 
             if ( ( repositoryList != null ) && !repositoryList.isEmpty() )
             {
                 for ( final Iterator<ArtifactRepository> it = repositoryList.iterator(); it.hasNext(); )
                 {
                     final ArtifactRepository repo = it.next();
 
                     if ( !encounteredUrls.contains( repo.getUrl() ) )
                     {
                         remoteRepos.add( repo );
                         encounteredUrls.add( repo.getUrl() );
                     }
                 }
             }
         }
 
         return remoteRepos;
     }
 
     protected ArtifactResolver getArtifactResolver()
     {
         return resolver;
     }
 
     protected DefaultDependencyResolver setArtifactResolver( final ArtifactResolver resolver )
     {
         this.resolver = resolver;
 
         return this;
     }
 
     protected ArtifactMetadataSource getArtifactMetadataSource()
     {
         return metadataSource;
     }
 
     protected DefaultDependencyResolver setArtifactMetadataSource( final ArtifactMetadataSource metadataSource )
     {
         this.metadataSource = metadataSource;
 
         return this;
     }
 
     protected ArtifactFactory getArtifactFactory()
     {
         return factory;
     }
 
     protected DefaultDependencyResolver setArtifactFactory( final ArtifactFactory factory )
     {
         this.factory = factory;
 
         return this;
     }
 
     protected ArtifactCollector getArtifactCollector()
     {
         return collector;
     }
 
     protected DefaultDependencyResolver setArtifactCollector( final ArtifactCollector collector )
     {
         this.collector = collector;
 
         return this;
     }
 
     protected DefaultDependencyResolver setLogger( final Logger logger )
     {
         enableLogging( logger );
 
         return this;
     }
 
 }

1		package org.apache.maven.plugin.assembly.artifact;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.util.ArrayList;
23		import java.util.Collections;
24		import java.util.HashSet;
25		import java.util.Iterator;
26		import java.util.LinkedHashSet;
27		import java.util.List;
28		import java.util.Set;
29
30		import org.apache.maven.artifact.Artifact;
31		import org.apache.maven.artifact.factory.ArtifactFactory;
32		import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
33		import org.apache.maven.artifact.repository.ArtifactRepository;
34		import org.apache.maven.artifact.resolver.ArtifactCollector;
35		import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
36		import org.apache.maven.artifact.resolver.ArtifactResolutionException;
37		import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
38		import org.apache.maven.artifact.resolver.ArtifactResolver;
39		import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException;
40		import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
41		import org.apache.maven.plugin.assembly.AssemblerConfigurationSource;
42		import org.apache.maven.plugin.assembly.AssemblyContext;
43		import org.apache.maven.plugin.assembly.archive.ArchiveCreationException;
44		import org.apache.maven.plugin.assembly.archive.phase.ModuleSetAssemblyPhase;
45		import org.apache.maven.plugin.assembly.model.Assembly;
46		import org.apache.maven.plugin.assembly.model.DependencySet;
47		import org.apache.maven.plugin.assembly.model.ModuleBinaries;
48		import org.apache.maven.plugin.assembly.model.ModuleSet;
49		import org.apache.maven.plugin.assembly.model.Repository;
50		import org.apache.maven.plugin.assembly.utils.FilterUtils;
51		import org.apache.maven.project.MavenProject;
52		import org.apache.maven.project.artifact.InvalidDependencyVersionException;
53		import org.codehaus.plexus.component.annotations.Component;
54		import org.codehaus.plexus.component.annotations.Requirement;
55		import org.codehaus.plexus.logging.AbstractLogEnabled;
56		import org.codehaus.plexus.logging.Logger;
57		import org.codehaus.plexus.util.StringUtils;
58
59		/**
60		* @author jdcasey
61		* @version $Id: DefaultDependencyResolver.java 1163853 2011-08-31 22:42:32Z jdcasey $
62		*/
63		@Component( role = DependencyResolver.class )
64		public class DefaultDependencyResolver
65		extends AbstractLogEnabled
66		implements DependencyResolver
67		{
68
69		@Requirement
70		private ArtifactResolver resolver;
71
72		@Requirement
73		private ArtifactMetadataSource metadataSource;
74
75		@Requirement
76		private ArtifactFactory factory;
77
78		@Requirement
79		private ArtifactCollector collector;
80
81		public DefaultDependencyResolver()
82	0	{
83		// for plexus init
84	0	}
85
86		protected DefaultDependencyResolver( final ArtifactResolver resolver, final ArtifactMetadataSource metadataSource,
87		final ArtifactFactory factory, final ArtifactCollector collector,
88		final Logger logger )
89	12	{
90	12	this.resolver = resolver;
91	12	this.metadataSource = metadataSource;
92	12	this.factory = factory;
93	12	this.collector = collector;
94
95	12	enableLogging( logger );
96	12	}
97
98		public void resolve( final Assembly assembly, final AssemblerConfigurationSource configSource,
99		final AssemblyContext context )
100		throws DependencyResolutionException
101		{
102	0	final MavenProject currentProject = configSource.getProject();
103
104	0	final ResolutionManagementInfo info = new ResolutionManagementInfo( currentProject );
105	0	getRepositoryResolutionRequirements( assembly, info, currentProject );
106	0	getDependencySetResolutionRequirements( assembly, assembly.getDependencySets(), info, currentProject );
107	0	getModuleSetResolutionRequirements( assembly, info, configSource );
108
109	0	if ( !info.isResolutionRequired() )
110		{
111	0	context.setResolvedArtifacts( new HashSet<Artifact>() );
112	0	return;
113		}
114
115	0	final List<ArtifactRepository> repos =
116		aggregateRemoteArtifactRepositories( configSource.getRemoteRepositories(), info.getEnabledProjects() );
117
118	0	Set<Artifact> artifacts = info.getArtifacts();
119	0	if ( info.isResolvedTransitively() )
120		{
121	0	getLogger().debug( "Resolving project dependencies transitively." );
122	0	artifacts = resolveTransitively( artifacts, repos, info, configSource );
123		}
124		else
125		{
126	0	getLogger().debug( "Resolving project dependencies ONLY. Transitive dependencies WILL NOT be included in the results." );
127	0	artifacts = resolveNonTransitively( assembly, artifacts, configSource, repos );
128		}
129
130	0	context.setResolvedArtifacts( artifacts );
131	0	}
132
133		protected Set<Artifact> resolveNonTransitively( final Assembly assembly, final Set<Artifact> dependencyArtifacts,
134		final AssemblerConfigurationSource configSource,
135		final List<ArtifactRepository> repos )
136		throws DependencyResolutionException
137		{
138
139	0	final List<Artifact> missing = new ArrayList<Artifact>();
140	0	final Set<Artifact> resolved = new LinkedHashSet<Artifact>();
141	0	for ( final Iterator<Artifact> it = dependencyArtifacts.iterator(); it.hasNext(); )
142		{
143	0	final Artifact depArtifact = it.next();
144
145		try
146		{
147	0	resolver.resolve( depArtifact, repos, configSource.getLocalRepository() );
148	0	resolved.add( depArtifact );
149		}
150	0	catch ( final ArtifactResolutionException e )
151		{
152	0	if ( getLogger().isDebugEnabled() )
153		{
154	0	getLogger().debug( "Failed to resolve: " + depArtifact.getId() + " for assembly: "
155		+ assembly.getId() );
156		}
157	0	missing.add( depArtifact );
158		}
159	0	catch ( final ArtifactNotFoundException e )
160		{
161	0	if ( getLogger().isDebugEnabled() )
162		{
163	0	getLogger().debug( "Failed to resolve: " + depArtifact.getId() + " for assembly: "
164		+ assembly.getId() );
165		}
166	0	missing.add( depArtifact );
167	0	}
168	0	}
169
170	0	if ( !missing.isEmpty() )
171		{
172	0	final MavenProject project = configSource.getProject();
173	0	final Artifact rootArtifact = project.getArtifact();
174
175	0	final Throwable error =
176		new MultipleArtifactsNotFoundException( rootArtifact, new ArrayList<Artifact>( resolved ), missing,
177		repos );
178
179	0	throw new DependencyResolutionException( "Failed to resolve dependencies for: " + assembly.getId(), error );
180		}
181
182	0	return resolved;
183		}
184
185		@SuppressWarnings( "unchecked" )
186		private Set<Artifact> resolveTransitively( final Set<Artifact> dependencyArtifacts,
187		final List<ArtifactRepository> repos,
188		final ResolutionManagementInfo info,
189		final AssemblerConfigurationSource configSource )
190		throws DependencyResolutionException
191		{
192	0	final MavenProject project = configSource.getProject();
193
194	0	final ArtifactFilter filter = info.getScopeFilter();
195	0	final ArtifactRepository localRepository = configSource.getLocalRepository();
196
197		ArtifactResolutionResult result;
198		try
199		{
200	0	result =
201		resolver.resolveTransitively( dependencyArtifacts, project.getArtifact(),
202		project.getManagedVersionMap(), localRepository, repos, metadataSource,
203		filter );
204		}
205	0	catch ( final ArtifactResolutionException e )
206		{
207	0	throw new DependencyResolutionException( "Failed to resolve dependencies for assembly: ", e );
208		}
209	0	catch ( final ArtifactNotFoundException e )
210		{
211	0	throw new DependencyResolutionException( "Failed to resolve dependencies for assembly: ", e );
212	0	}
213
214	0	getLogger().debug( "While resolving dependencies of " + project.getId() + ":" );
215
216	0	FilterUtils.reportFilteringStatistics( Collections.singleton( filter ), getLogger() );
217
218	0	return result.getArtifacts();
219		}
220
221		protected void getRepositoryResolutionRequirements( final Assembly assembly,
222		final ResolutionManagementInfo requirements,
223		final MavenProject... project )
224		{
225	3	final List<Repository> repositories = assembly.getRepositories();
226
227	3	if ( repositories != null && !repositories.isEmpty() )
228		{
229	3	requirements.setResolutionRequired( true );
230	3	for ( final Repository repo : repositories )
231		{
232	6	enableScope( repo.getScope(), requirements );
233		}
234		}
235	3	}
236
237		protected void getModuleSetResolutionRequirements( final Assembly assembly,
238		final ResolutionManagementInfo requirements,
239		final AssemblerConfigurationSource configSource )
240		throws DependencyResolutionException
241		{
242	3	final List<ModuleSet> moduleSets = assembly.getModuleSets();
243
244	3	if ( moduleSets != null && !moduleSets.isEmpty() )
245		{
246	3	for ( final ModuleSet set : moduleSets )
247		{
248	6	final ModuleBinaries binaries = set.getBinaries();
249	6	if ( binaries != null )
250		{
251		Set<MavenProject> projects;
252		try
253		{
254	6	projects = ModuleSetAssemblyPhase.getModuleProjects( set, configSource, getLogger() );
255		}
256	0	catch ( final ArchiveCreationException e )
257		{
258	0	throw new DependencyResolutionException(
259		"Error determining project-set for moduleSet with binaries.",
260		e );
261	6	}
262
263	6	if ( projects != null && !projects.isEmpty() )
264		{
265	3	for ( final MavenProject p : projects )
266		{
267	9	requirements.enableProjectResolution( p );
268
269	9	if ( p.getArtifact() == null )
270		{
271		// TODO: such a call in MavenMetadataSource too - packaging not really the intention of
272		// type
273	0	final Artifact artifact =
274		factory.createBuildArtifact( p.getGroupId(), p.getArtifactId(), p.getVersion(),
275		p.getPackaging() );
276	0	p.setArtifact( artifact );
277	9	}
278		}
279		}
280
281	6	if ( binaries.isIncludeDependencies() )
282		{
283	6	getDependencySetResolutionRequirements( assembly,
284		ModuleSetAssemblyPhase.getDependencySets( binaries ),
285		requirements, projects.toArray( new MavenProject[] {} ) );
286		}
287		}
288	6	}
289		}
290	3	}
291
292		@SuppressWarnings( "unchecked" )
293		protected void getDependencySetResolutionRequirements( final Assembly assembly, final List<DependencySet> depSets,
294		final ResolutionManagementInfo requirements,
295		final MavenProject... projects )
296		throws DependencyResolutionException
297		{
298	9	if ( depSets != null && !depSets.isEmpty() )
299		{
300	9	requirements.setResolutionRequired( true );
301
302	9	for ( final DependencySet set : depSets )
303		{
304	12	requirements.setResolvedTransitively( set.isUseTransitiveDependencies() );
305
306	12	enableScope( set.getScope(), requirements );
307		}
308
309	21	for ( final MavenProject project : projects )
310		{
311	12	if ( project == null )
312		{
313	0	continue;
314		}
315
316	12	Set<Artifact> dependencyArtifacts = project.getDependencyArtifacts();
317	12	if ( dependencyArtifacts == null )
318		{
319		try
320		{
321	12	dependencyArtifacts = project.createArtifacts( factory, null, requirements.getScopeFilter() );
322	12	project.setDependencyArtifacts( dependencyArtifacts );
323		}
324	0	catch ( final InvalidDependencyVersionException e )
325		{
326	0	throw new DependencyResolutionException(
327		"Failed to create dependency artifacts for resolution. Assembly: "
328		+ assembly.getId(), e );
329	12	}
330		}
331
332	12	requirements.addArtifacts( dependencyArtifacts );
333	12	getLogger().debug( "Dependencies for project: " + project.getId() + " are:\n"
334		+ StringUtils.join( dependencyArtifacts.iterator(), "\n" ) );
335		}
336		}
337	9	}
338
339		private void enableScope( final String scope, final ResolutionManagementInfo requirements )
340		{
341	18	if ( Artifact.SCOPE_COMPILE.equals( scope ) )
342		{
343	9	requirements.enableCompileScope();
344		}
345	9	else if ( Artifact.SCOPE_PROVIDED.equals( scope ) )
346		{
347	0	requirements.enableProvidedScope();
348		}
349	9	else if ( Artifact.SCOPE_RUNTIME.equals( scope ) )
350		{
351	0	requirements.enableRuntimeScope();
352		}
353	9	else if ( Artifact.SCOPE_SYSTEM.equals( scope ) )
354		{
355	6	requirements.enableSystemScope();
356		}
357	3	else if ( Artifact.SCOPE_TEST.equals( scope ) )
358		{
359	3	requirements.enableTestScope();
360		}
361	18	}
362
363		@SuppressWarnings( "unchecked" )
364		protected List<ArtifactRepository> aggregateRemoteArtifactRepositories( final List<ArtifactRepository> remoteRepositories,
365		final Set<MavenProject> projects )
366		{
367	3	final List<List<ArtifactRepository>> repoLists = new ArrayList<List<ArtifactRepository>>();
368
369	3	repoLists.add( remoteRepositories );
370	3	for ( final MavenProject project : projects )
371		{
372	3	repoLists.add( project.getRemoteArtifactRepositories() );
373		}
374
375	3	final List<ArtifactRepository> remoteRepos = new ArrayList<ArtifactRepository>();
376	3	final Set<String> encounteredUrls = new HashSet<String>();
377
378	3	for ( final Iterator<List<ArtifactRepository>> listIterator = repoLists.iterator(); listIterator.hasNext(); )
379		{
380	6	final List<ArtifactRepository> repositoryList = listIterator.next();
381
382	6	if ( ( repositoryList != null ) && !repositoryList.isEmpty() )
383		{
384	6	for ( final Iterator<ArtifactRepository> it = repositoryList.iterator(); it.hasNext(); )
385		{
386	12	final ArtifactRepository repo = it.next();
387
388	12	if ( !encounteredUrls.contains( repo.getUrl() ) )
389		{
390	9	remoteRepos.add( repo );
391	9	encounteredUrls.add( repo.getUrl() );
392		}
393	12	}
394		}
395	6	}
396
397	3	return remoteRepos;
398		}
399
400		protected ArtifactResolver getArtifactResolver()
401		{
402	0	return resolver;
403		}
404
405		protected DefaultDependencyResolver setArtifactResolver( final ArtifactResolver resolver )
406		{
407	0	this.resolver = resolver;
408
409	0	return this;
410		}
411
412		protected ArtifactMetadataSource getArtifactMetadataSource()
413		{
414	0	return metadataSource;
415		}
416
417		protected DefaultDependencyResolver setArtifactMetadataSource( final ArtifactMetadataSource metadataSource )
418		{
419	0	this.metadataSource = metadataSource;
420
421	0	return this;
422		}
423
424		protected ArtifactFactory getArtifactFactory()
425		{
426	0	return factory;
427		}
428
429		protected DefaultDependencyResolver setArtifactFactory( final ArtifactFactory factory )
430		{
431	0	this.factory = factory;
432
433	0	return this;
434		}
435
436		protected ArtifactCollector getArtifactCollector()
437		{
438	0	return collector;
439		}
440
441		protected DefaultDependencyResolver setArtifactCollector( final ArtifactCollector collector )
442		{
443	0	this.collector = collector;
444
445	0	return this;
446		}
447
448		protected DefaultDependencyResolver setLogger( final Logger logger )
449		{
450	0	enableLogging( logger );
451
452	0	return this;
453		}
454
455		}