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