1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.plugin;
20
21 import java.io.File;
22 import java.util.Properties;
23
24 import org.apache.maven.execution.MavenSession;
25 import org.apache.maven.plugin.descriptor.MojoDescriptor;
26 import org.apache.maven.plugin.descriptor.PluginDescriptor;
27 import org.apache.maven.project.MavenProject;
28 import org.apache.maven.project.path.PathTranslator;
29 import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
30 import org.codehaus.plexus.component.configurator.expression.TypeAwareExpressionEvaluator;
31 import org.codehaus.plexus.logging.Logger;
32 import org.codehaus.plexus.util.introspection.ReflectionValueExtractor;
33
34
35
36
37
38
39
40
41
42
43
44
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 public class PluginParameterExpressionEvaluator implements TypeAwareExpressionEvaluator {
76 private MavenSession session;
77
78 private MojoExecution mojoExecution;
79
80 private MavenProject project;
81
82 private String basedir;
83
84 private Properties properties;
85
86 @Deprecated
87 public PluginParameterExpressionEvaluator(
88 MavenSession session,
89 MojoExecution mojoExecution,
90 PathTranslator pathTranslator,
91 Logger logger,
92 MavenProject project,
93 Properties properties) {
94 this(session, mojoExecution);
95 }
96
97 public PluginParameterExpressionEvaluator(MavenSession session) {
98 this(session, null);
99 }
100
101 public PluginParameterExpressionEvaluator(MavenSession session, MojoExecution mojoExecution) {
102 this.session = session;
103 this.mojoExecution = mojoExecution;
104 this.properties = new Properties();
105 this.project = session.getCurrentProject();
106
107
108
109
110
111 this.properties.putAll(session.getUserProperties());
112 this.properties.putAll(session.getSystemProperties());
113
114 String basedir = null;
115
116 if (project != null) {
117 File projectFile = project.getBasedir();
118
119
120 if (projectFile != null) {
121 basedir = projectFile.getAbsolutePath();
122 }
123 }
124
125 if (basedir == null) {
126 basedir = session.getExecutionRootDirectory();
127 }
128
129 if (basedir == null) {
130 basedir = System.getProperty("user.dir");
131 }
132
133 this.basedir = basedir;
134 }
135
136 @Override
137 public Object evaluate(String expr) throws ExpressionEvaluationException {
138 return evaluate(expr, null);
139 }
140
141 @Override
142 @SuppressWarnings("checkstyle:methodlength")
143 public Object evaluate(String expr, Class<?> type) throws ExpressionEvaluationException {
144 Object value = null;
145
146 if (expr == null) {
147 return null;
148 }
149
150 String expression = stripTokens(expr);
151 if (expression.equals(expr)) {
152 int index = expr.indexOf("${");
153 if (index >= 0) {
154 int lastIndex = expr.indexOf('}', index);
155 if (lastIndex >= 0) {
156 String retVal = expr.substring(0, index);
157
158 if ((index > 0) && (expr.charAt(index - 1) == '$')) {
159 retVal += expr.substring(index + 1, lastIndex + 1);
160 } else {
161 Object subResult = evaluate(expr.substring(index, lastIndex + 1));
162
163 if (subResult != null) {
164 retVal += subResult;
165 } else {
166 retVal += "$" + expr.substring(index + 1, lastIndex + 1);
167 }
168 }
169
170 retVal += evaluate(expr.substring(lastIndex + 1));
171 return retVal;
172 }
173 }
174
175
176 return expression.replace("$$", "$");
177 }
178
179 MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
180
181 if ("localRepository".equals(expression)) {
182 value = session.getLocalRepository();
183 } else if ("session".equals(expression)) {
184 value = session;
185 } else if (expression.startsWith("session")) {
186 try {
187 int pathSeparator = expression.indexOf('/');
188
189 if (pathSeparator > 0) {
190 String pathExpression = expression.substring(1, pathSeparator);
191 value = ReflectionValueExtractor.evaluate(pathExpression, session);
192 value = value + expression.substring(pathSeparator);
193 } else {
194 value = ReflectionValueExtractor.evaluate(expression.substring(1), session);
195 }
196 } catch (Exception e) {
197
198 throw new ExpressionEvaluationException(
199 "Error evaluating plugin parameter expression: " + expression, e);
200 }
201 } else if ("reactorProjects".equals(expression)) {
202 value = session.getProjects();
203 } else if ("mojoExecution".equals(expression)) {
204 value = mojoExecution;
205 } else if ("project".equals(expression)) {
206 value = project;
207 } else if ("executedProject".equals(expression)) {
208 value = project.getExecutionProject();
209 } else if (expression.startsWith("project") || expression.startsWith("pom")) {
210 try {
211 int pathSeparator = expression.indexOf('/');
212
213 if (pathSeparator > 0) {
214 String pathExpression = expression.substring(0, pathSeparator);
215 value = ReflectionValueExtractor.evaluate(pathExpression, project);
216 value = value + expression.substring(pathSeparator);
217 } else {
218 value = ReflectionValueExtractor.evaluate(expression.substring(1), project);
219 }
220 } catch (Exception e) {
221
222 throw new ExpressionEvaluationException(
223 "Error evaluating plugin parameter expression: " + expression, e);
224 }
225 } else if (expression.equals("repositorySystemSession")) {
226 value = session.getRepositorySession();
227 } else if (expression.equals("mojo")) {
228 value = mojoExecution;
229 } else if (expression.startsWith("mojo")) {
230 try {
231 int pathSeparator = expression.indexOf('/');
232
233 if (pathSeparator > 0) {
234 String pathExpression = expression.substring(1, pathSeparator);
235 value = ReflectionValueExtractor.evaluate(pathExpression, mojoExecution);
236 value = value + expression.substring(pathSeparator);
237 } else {
238 value = ReflectionValueExtractor.evaluate(expression.substring(1), mojoExecution);
239 }
240 } catch (Exception e) {
241
242 throw new ExpressionEvaluationException(
243 "Error evaluating plugin parameter expression: " + expression, e);
244 }
245 } else if (expression.equals("plugin")) {
246 value = mojoDescriptor.getPluginDescriptor();
247 } else if (expression.startsWith("plugin")) {
248 try {
249 int pathSeparator = expression.indexOf('/');
250
251 PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
252
253 if (pathSeparator > 0) {
254 String pathExpression = expression.substring(1, pathSeparator);
255 value = ReflectionValueExtractor.evaluate(pathExpression, pluginDescriptor);
256 value = value + expression.substring(pathSeparator);
257 } else {
258 value = ReflectionValueExtractor.evaluate(expression.substring(1), pluginDescriptor);
259 }
260 } catch (Exception e) {
261 throw new ExpressionEvaluationException(
262 "Error evaluating plugin parameter expression: " + expression, e);
263 }
264 } else if ("settings".equals(expression)) {
265 value = session.getSettings();
266 } else if (expression.startsWith("settings")) {
267 try {
268 int pathSeparator = expression.indexOf('/');
269
270 if (pathSeparator > 0) {
271 String pathExpression = expression.substring(1, pathSeparator);
272 value = ReflectionValueExtractor.evaluate(pathExpression, session.getSettings());
273 value = value + expression.substring(pathSeparator);
274 } else {
275 value = ReflectionValueExtractor.evaluate(expression.substring(1), session.getSettings());
276 }
277 } catch (Exception e) {
278
279 throw new ExpressionEvaluationException(
280 "Error evaluating plugin parameter expression: " + expression, e);
281 }
282 } else if ("basedir".equals(expression)) {
283 value = basedir;
284 } else if (expression.startsWith("basedir")) {
285 int pathSeparator = expression.indexOf('/');
286
287 if (pathSeparator > 0) {
288 value = basedir + expression.substring(pathSeparator);
289 }
290 }
291
292
293
294
295
296
297
298
299
300 if (value != null && type != null && !(value instanceof String) && !isTypeCompatible(type, value)) {
301 value = null;
302 }
303
304 if (value == null) {
305
306
307 if (properties != null) {
308
309
310
311
312
313 value = properties.getProperty(expression);
314 }
315
316 if ((value == null) && ((project != null) && (project.getProperties() != null))) {
317 value = project.getProperties().getProperty(expression);
318 }
319 }
320
321 if (value instanceof String) {
322
323
324 String val = (String) value;
325
326 int exprStartDelimiter = val.indexOf("${");
327
328 if (exprStartDelimiter >= 0) {
329 if (exprStartDelimiter > 0) {
330 value = val.substring(0, exprStartDelimiter) + evaluate(val.substring(exprStartDelimiter));
331 } else {
332 value = evaluate(val.substring(exprStartDelimiter));
333 }
334 }
335 }
336
337 return value;
338 }
339
340 private static boolean isTypeCompatible(Class<?> type, Object value) {
341 if (type.isInstance(value)) {
342 return true;
343 }
344
345 return ((type.isPrimitive() || type.getName().startsWith("java.lang."))
346 && value.getClass().getName().startsWith("java.lang."));
347 }
348
349 private String stripTokens(String expr) {
350 if (expr.startsWith("${") && (expr.indexOf('}') == expr.length() - 1)) {
351 expr = expr.substring(2, expr.length() - 1);
352 }
353 return expr;
354 }
355
356 @Override
357 public File alignToBaseDirectory(File file) {
358
359
360 if (file != null) {
361 if (file.isAbsolute()) {
362
363 } else if (file.getPath().startsWith(File.separator)) {
364
365 file = file.getAbsoluteFile();
366 } else {
367
368 file = new File(new File(basedir, file.getPath()).toURI().normalize()).getAbsoluteFile();
369 }
370 }
371 return file;
372 }
373 }