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
180 MojoDescriptor mojoDescriptor = mojoExecution != null ? mojoExecution.getMojoDescriptor() : null;
181
182 if ("localRepository".equals(expression)) {
183 value = session.getLocalRepository();
184 } else if ("session".equals(expression)) {
185 value = session;
186 } else if (expression.startsWith("session")) {
187 try {
188 int pathSeparator = expression.indexOf('/');
189
190 if (pathSeparator > 0) {
191 String pathExpression = expression.substring(1, pathSeparator);
192 value = ReflectionValueExtractor.evaluate(pathExpression, session);
193 value = value + expression.substring(pathSeparator);
194 } else {
195 value = ReflectionValueExtractor.evaluate(expression.substring(1), session);
196 }
197 } catch (Exception e) {
198
199 throw new ExpressionEvaluationException(
200 "Error evaluating plugin parameter expression: " + expression, e);
201 }
202 } else if ("reactorProjects".equals(expression)) {
203 value = session.getProjects();
204 } else if ("mojoExecution".equals(expression)) {
205 value = mojoExecution;
206 } else if ("project".equals(expression)) {
207 value = project;
208 } else if ("executedProject".equals(expression)) {
209 value = project.getExecutionProject();
210 } else if (expression.startsWith("project") || expression.startsWith("pom")) {
211 try {
212 int pathSeparator = expression.indexOf('/');
213
214 if (pathSeparator > 0) {
215 String pathExpression = expression.substring(0, pathSeparator);
216 value = ReflectionValueExtractor.evaluate(pathExpression, project);
217 value = value + expression.substring(pathSeparator);
218 } else {
219 value = ReflectionValueExtractor.evaluate(expression.substring(1), project);
220 }
221 } catch (Exception e) {
222
223 throw new ExpressionEvaluationException(
224 "Error evaluating plugin parameter expression: " + expression, e);
225 }
226 } else if (expression.equals("repositorySystemSession")) {
227 value = session.getRepositorySession();
228 } else if (expression.equals("mojo")) {
229 value = mojoExecution;
230 } else if (expression.startsWith("mojo") && mojoExecution != null) {
231 try {
232 int pathSeparator = expression.indexOf('/');
233
234 if (pathSeparator > 0) {
235 String pathExpression = expression.substring(1, pathSeparator);
236 value = ReflectionValueExtractor.evaluate(pathExpression, mojoExecution);
237 value = value + expression.substring(pathSeparator);
238 } else {
239 value = ReflectionValueExtractor.evaluate(expression.substring(1), mojoExecution);
240 }
241 } catch (Exception e) {
242
243 throw new ExpressionEvaluationException(
244 "Error evaluating plugin parameter expression: " + expression, e);
245 }
246 } else if (expression.equals("plugin")) {
247 value = mojoDescriptor != null ? mojoDescriptor.getPluginDescriptor() : null;
248 } else if (expression.startsWith("plugin") && mojoDescriptor != null) {
249 try {
250 int pathSeparator = expression.indexOf('/');
251
252 PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
253
254 if (pathSeparator > 0) {
255 String pathExpression = expression.substring(1, pathSeparator);
256 value = ReflectionValueExtractor.evaluate(pathExpression, pluginDescriptor);
257 value = value + expression.substring(pathSeparator);
258 } else {
259 value = ReflectionValueExtractor.evaluate(expression.substring(1), pluginDescriptor);
260 }
261 } catch (Exception e) {
262 throw new ExpressionEvaluationException(
263 "Error evaluating plugin parameter expression: " + expression, e);
264 }
265 } else if ("settings".equals(expression)) {
266 value = session.getSettings();
267 } else if (expression.startsWith("settings")) {
268 try {
269 int pathSeparator = expression.indexOf('/');
270
271 if (pathSeparator > 0) {
272 String pathExpression = expression.substring(1, pathSeparator);
273 value = ReflectionValueExtractor.evaluate(pathExpression, session.getSettings());
274 value = value + expression.substring(pathSeparator);
275 } else {
276 value = ReflectionValueExtractor.evaluate(expression.substring(1), session.getSettings());
277 }
278 } catch (Exception e) {
279
280 throw new ExpressionEvaluationException(
281 "Error evaluating plugin parameter expression: " + expression, e);
282 }
283 } else if ("basedir".equals(expression)) {
284 value = basedir;
285 } else if (expression.startsWith("basedir")) {
286 int pathSeparator = expression.indexOf('/');
287
288 if (pathSeparator > 0) {
289 value = basedir + expression.substring(pathSeparator);
290 }
291 }
292
293
294
295
296
297
298
299
300
301 if (value != null && type != null && !(value instanceof String) && !isTypeCompatible(type, value)) {
302 value = null;
303 }
304
305 if (value == null) {
306
307
308 if (properties != null) {
309
310
311
312
313
314 value = properties.getProperty(expression);
315 }
316
317 if ((value == null) && ((project != null) && (project.getProperties() != null))) {
318 value = project.getProperties().getProperty(expression);
319 }
320 }
321
322 if (value instanceof String) {
323
324
325 String val = (String) value;
326
327 int exprStartDelimiter = val.indexOf("${");
328
329 if (exprStartDelimiter >= 0) {
330 if (exprStartDelimiter > 0) {
331 value = val.substring(0, exprStartDelimiter) + evaluate(val.substring(exprStartDelimiter));
332 } else {
333 value = evaluate(val.substring(exprStartDelimiter));
334 }
335 }
336 }
337
338 return value;
339 }
340
341 private static boolean isTypeCompatible(Class<?> type, Object value) {
342 if (type.isInstance(value)) {
343 return true;
344 }
345
346 return ((type.isPrimitive() || type.getName().startsWith("java.lang."))
347 && value.getClass().getName().startsWith("java.lang."));
348 }
349
350 private String stripTokens(String expr) {
351 if (expr.startsWith("${") && (expr.indexOf('}') == expr.length() - 1)) {
352 expr = expr.substring(2, expr.length() - 1);
353 }
354 return expr;
355 }
356
357 @Override
358 public File alignToBaseDirectory(File file) {
359
360
361 if (file != null) {
362 if (file.isAbsolute()) {
363
364 } else if (file.getPath().startsWith(File.separator)) {
365
366 file = file.getAbsoluteFile();
367 } else {
368
369 file = new File(new File(basedir, file.getPath()).toURI().normalize()).getAbsoluteFile();
370 }
371 }
372 return file;
373 }
374 }