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( defaultValue = "archetype.properties", 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
229
230
231 @Override
232 public void execute()
233 throws MojoExecutionException, MojoFailureException
234 {
235 Properties executionProperties = session.getExecutionProperties();
236 try
237 {
238 if ( propertyFile != null )
239 {
240 propertyFile.getParentFile().mkdirs();
241 }
242
243 List<String> languages = getLanguages( archetypeLanguages, propertyFile );
244
245 Properties properties =
246 configurator.configureArchetypeCreation( project, Boolean.valueOf( interactive ), executionProperties,
247 propertyFile, languages );
248
249 List<String> filtereds = getFilteredExtensions( archetypeFilteredExtentions, propertyFile );
250
251 ArchetypeCreationRequest request =
252 new ArchetypeCreationRequest().setDefaultEncoding( defaultEncoding ).setProject( project )
253 .setProperties( properties ).setLanguages( languages )
254 .setFiltereds( filtereds )
255 .setPreserveCData( preserveCData ).setKeepParent(
256 keepParent ).setPartialArchetype( partialArchetype )
257 .setLocalRepository( localRepository ).setProjectBuildingRequest( session.getProjectBuildingRequest() )
258 .setPackageName( packageName ).setPostPhase(
259 archetypePostPhase ).setOutputDirectory( outputDirectory ).setSettingsFile( session.getRequest().getUserSettingsFile() );
260
261 ArchetypeCreationResult result = manager.createArchetypeFromProject( request );
262
263 if ( result.getCause() != null )
264 {
265 throw new MojoFailureException( result.getCause(), result.getCause().getMessage(),
266 result.getCause().getMessage() );
267 }
268
269 getLog().info( "Archetype project created in " + outputDirectory );
270
271 if ( testMode )
272 {
273
274
275
276
277
278
279
280
281
282 }
283
284 }
285 catch ( MojoFailureException ex )
286 {
287 throw ex;
288 }
289 catch ( Exception ex )
290 {
291 throw new MojoFailureException( ex, ex.getMessage(), ex.getMessage() );
292 }
293 }
294
295 private List<String> getFilteredExtensions( String archetypeFilteredExtentions, File propertyFile )
296 {
297 List<String> filteredExtensions = new ArrayList<>();
298
299 if ( StringUtils.isNotEmpty( archetypeFilteredExtentions ) )
300 {
301 filteredExtensions.addAll( Arrays.asList( StringUtils.split( archetypeFilteredExtentions, "," ) ) );
302
303 getLog().debug( "Found in command line extensions = " + filteredExtensions );
304 }
305
306 if ( filteredExtensions.isEmpty() && propertyFile != null && propertyFile.exists() )
307 {
308 Properties properties = PropertyUtils.loadProperties( propertyFile );
309
310 String extensions = properties.getProperty( Constants.ARCHETYPE_FILTERED_EXTENSIONS );
311 if ( StringUtils.isNotEmpty( extensions ) )
312 {
313 filteredExtensions.addAll( Arrays.asList( StringUtils.split( extensions, "," ) ) );
314 }
315
316 getLog().debug( "Found in propertyFile " + propertyFile.getName() + " extensions = " + filteredExtensions );
317 }
318
319 if ( filteredExtensions.isEmpty() )
320 {
321 filteredExtensions.addAll( Constants.DEFAULT_FILTERED_EXTENSIONS );
322
323 getLog().debug( "Using default extensions = " + filteredExtensions );
324 }
325
326 return filteredExtensions;
327 }
328
329 private List<String> getLanguages( String archetypeLanguages, File propertyFile )
330 {
331 List<String> resultingLanguages = new ArrayList<>();
332
333 if ( StringUtils.isNotEmpty( archetypeLanguages ) )
334 {
335 resultingLanguages.addAll( Arrays.asList( StringUtils.split( archetypeLanguages, "," ) ) );
336
337 getLog().debug( "Found in command line languages = " + resultingLanguages );
338 }
339
340 if ( resultingLanguages.isEmpty() && propertyFile != null && propertyFile.exists() )
341 {
342 Properties properties = PropertyUtils.loadProperties( propertyFile );
343
344 String languages = properties.getProperty( Constants.ARCHETYPE_LANGUAGES );
345 if ( StringUtils.isNotEmpty( languages ) )
346 {
347 resultingLanguages.addAll( Arrays.asList( StringUtils.split( languages, "," ) ) );
348 }
349
350 getLog().debug( "Found in propertyFile " + propertyFile.getName() + " languages = " + resultingLanguages );
351 }
352
353 if ( resultingLanguages.isEmpty() )
354 {
355 resultingLanguages.addAll( Constants.DEFAULT_LANGUAGES );
356
357 getLog().debug( "Using default languages = " + resultingLanguages );
358 }
359
360 return resultingLanguages;
361 }
362 }