1 package org.apache.maven.archetype.mojos;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.archetype.ArchetypeCreationRequest;
23 import org.apache.maven.archetype.ArchetypeCreationResult;
24 import org.apache.maven.archetype.ArchetypeManager;
25 import org.apache.maven.archetype.common.Constants;
26 import org.apache.maven.archetype.ui.creation.ArchetypeCreationConfigurator;
27 import org.apache.maven.artifact.repository.ArtifactRepository;
28 import org.apache.maven.execution.MavenSession;
29 import org.apache.maven.plugin.AbstractMojo;
30 import org.apache.maven.plugin.MojoExecutionException;
31 import org.apache.maven.plugin.MojoFailureException;
32 import org.apache.maven.plugins.annotations.Component;
33 import org.apache.maven.plugins.annotations.Execute;
34 import org.apache.maven.plugins.annotations.LifecyclePhase;
35 import org.apache.maven.plugins.annotations.Mojo;
36 import org.apache.maven.plugins.annotations.Parameter;
37 import org.apache.maven.project.MavenProject;
38 import org.codehaus.plexus.util.PropertyUtils;
39 import org.codehaus.plexus.util.StringUtils;
40
41 import java.io.File;
42 import java.util.ArrayList;
43 import java.util.Arrays;
44 import java.util.List;
45 import java.util.Properties;
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100 @Mojo( name = "create-from-project", requiresProject = true, aggregator = true )
101 @Execute( phase = LifecyclePhase.GENERATE_SOURCES )
102 public class CreateArchetypeFromProjectMojo
103 extends AbstractMojo
104 {
105
106 @Component
107 private ArchetypeCreationConfigurator configurator;
108
109
110
111
112 @Parameter( property = "interactive", defaultValue = "false" )
113 private boolean interactive;
114
115 @Component
116 private ArchetypeManager manager;
117
118
119
120
121 @Parameter( property = "archetype.filteredExtentions" )
122 private String archetypeFilteredExtentions;
123
124
125
126
127 @Parameter( property = "archetype.languages" )
128 private String archetypeLanguages;
129
130
131
132
133 @Parameter( property = "archetype.encoding", defaultValue = "UTF-8" )
134 private String defaultEncoding;
135
136
137
138
139 @Parameter( property = "archetype.partialArchetype" )
140 private boolean partialArchetype = false;
141
142
143
144
145
146 @Parameter( property = "archetype.preserveCData" )
147 private boolean preserveCData = false;
148
149 @Parameter( defaultValue = "${localRepository}", readonly = true )
150 private ArtifactRepository localRepository;
151
152
153
154
155
156 @Parameter( property = "archetype.keepParent" )
157 private boolean keepParent = true;
158
159
160
161
162 @Parameter( defaultValue = "${project}", readonly = true, required = true )
163 private MavenProject project;
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199 @Parameter( property = "archetype.properties" )
200 private File propertyFile;
201
202
203
204
205
206 @Parameter( property = "archetype.postPhase", defaultValue = "package" )
207 private String archetypePostPhase;
208
209
210
211
212 @Parameter( defaultValue = "${project.build.directory}/generated-sources/archetype" )
213 private File outputDirectory;
214
215 @Parameter( property = "testMode" )
216 private boolean testMode;
217
218
219
220
221
222 @Parameter( property = "packageName" )
223 private String packageName;
224
225 @Parameter( defaultValue = "${session}", readonly = true, required = true )
226 private MavenSession session;
227
228 public void execute()
229 throws MojoExecutionException, MojoFailureException
230 {
231 Properties executionProperties = session.getExecutionProperties();
232 try
233 {
234 if ( propertyFile != null )
235 {
236 propertyFile.getParentFile().mkdirs();
237 }
238
239 List<String> languages = getLanguages( archetypeLanguages, propertyFile );
240
241 Properties properties =
242 configurator.configureArchetypeCreation( project, Boolean.valueOf( interactive ), executionProperties,
243 propertyFile, languages );
244
245 List<String> filtereds = getFilteredExtensions( archetypeFilteredExtentions, propertyFile );
246
247 ArchetypeCreationRequest request =
248 new ArchetypeCreationRequest().setDefaultEncoding( defaultEncoding ).setProject( project )
249 .setProperties( properties ).setLanguages( languages )
250 .setFiltereds( filtereds )
251 .setPreserveCData( preserveCData ).setKeepParent(
252 keepParent ).setPartialArchetype( partialArchetype )
253 .setLocalRepository( localRepository ).setProjectBuildingRequest( session.getProjectBuildingRequest() )
254 .setPackageName( packageName ).setPostPhase(
255 archetypePostPhase ).setOutputDirectory( outputDirectory );
256
257 ArchetypeCreationResult result = manager.createArchetypeFromProject( request );
258
259 if ( result.getCause() != null )
260 {
261 throw new MojoFailureException( result.getCause(), result.getCause().getMessage(),
262 result.getCause().getMessage() );
263 }
264
265 getLog().info( "Archetype project created in " + outputDirectory );
266
267 if ( testMode )
268 {
269
270
271
272
273
274
275
276
277
278 }
279
280 }
281 catch ( MojoFailureException ex )
282 {
283 throw ex;
284 }
285 catch ( Exception ex )
286 {
287 throw new MojoFailureException( ex, ex.getMessage(), ex.getMessage() );
288 }
289 }
290
291 private List<String> getFilteredExtensions( String archetypeFilteredExtentions, File propertyFile )
292 {
293 List<String> filteredExtensions = new ArrayList<String>();
294
295 if ( StringUtils.isNotEmpty( archetypeFilteredExtentions ) )
296 {
297 filteredExtensions.addAll( Arrays.asList( StringUtils.split( archetypeFilteredExtentions, "," ) ) );
298
299 getLog().debug( "Found in command line extensions = " + filteredExtensions );
300 }
301
302 if ( filteredExtensions.isEmpty() && propertyFile != null && propertyFile.exists() )
303 {
304 Properties properties = PropertyUtils.loadProperties( propertyFile );
305
306 String extensions = properties.getProperty( Constants.ARCHETYPE_FILTERED_EXTENSIONS );
307 if ( StringUtils.isNotEmpty( extensions ) )
308 {
309 filteredExtensions.addAll( Arrays.asList( StringUtils.split( extensions, "," ) ) );
310 }
311
312 getLog().debug( "Found in propertyFile " + propertyFile.getName() + " extensions = " + filteredExtensions );
313 }
314
315 if ( filteredExtensions.isEmpty() )
316 {
317 filteredExtensions.addAll( Constants.DEFAULT_FILTERED_EXTENSIONS );
318
319 getLog().debug( "Using default extensions = " + filteredExtensions );
320 }
321
322 return filteredExtensions;
323 }
324
325 private List<String> getLanguages( String archetypeLanguages, File propertyFile )
326 {
327 List<String> resultingLanguages = new ArrayList<String>();
328
329 if ( StringUtils.isNotEmpty( archetypeLanguages ) )
330 {
331 resultingLanguages.addAll( Arrays.asList( StringUtils.split( archetypeLanguages, "," ) ) );
332
333 getLog().debug( "Found in command line languages = " + resultingLanguages );
334 }
335
336 if ( resultingLanguages.isEmpty() && propertyFile != null && propertyFile.exists() )
337 {
338 Properties properties = PropertyUtils.loadProperties( propertyFile );
339
340 String languages = properties.getProperty( Constants.ARCHETYPE_LANGUAGES );
341 if ( StringUtils.isNotEmpty( languages ) )
342 {
343 resultingLanguages.addAll( Arrays.asList( StringUtils.split( languages, "," ) ) );
344 }
345
346 getLog().debug( "Found in propertyFile " + propertyFile.getName() + " languages = " + resultingLanguages );
347 }
348
349 if ( resultingLanguages.isEmpty() )
350 {
351 resultingLanguages.addAll( Constants.DEFAULT_LANGUAGES );
352
353 getLog().debug( "Using default languages = " + resultingLanguages );
354 }
355
356 return resultingLanguages;
357 }
358 }