Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

DefaultDependencyResolver

48%

70/146

59%

41/70

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