1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
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.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
29 import org.codehaus.plexus.component.configurator.expression.TypeAwareExpressionEvaluator;
30 import org.codehaus.plexus.util.introspection.ReflectionValueExtractor;
31
32 /**
33 * Evaluator for plugin parameters expressions. Content surrounded by <code>${</code> and <code>}</code> is evaluated.
34 * Recognized values are:
35 * <table border="1">
36 * <caption>Expression matrix</caption>
37 * <tr><th>expression</th> <th></th> <th>evaluation result</th></tr>
38 * <tr><td><code>session</code></td> <td></td> <td>the actual {@link MavenSession}</td></tr>
39 * <tr><td><code>session.*</code></td> <td>(since Maven 3)</td><td></td></tr>
40 * <tr><td><code>localRepository</code></td> <td></td>
41 * <td>{@link MavenSession#getLocalRepository()} DEPRECATED: Avoid use of {@link org.apache.maven.artifact.repository.ArtifactRepository} type. If you need access to local repository, switch to '${repositorySystemSession}' expression and get LRM from it instead. See <a href="https://issues.apache.org/jira/browse/MNG-7706">MNG-7706</a></td></tr>
42 * <tr><td><code>reactorProjects</code></td> <td></td> <td>{@link MavenSession#getProjects()}</td></tr>
43 * <tr><td><code>repositorySystemSession</code></td><td> (since Maven 3)</td>
44 * <td>{@link MavenSession#getRepositorySession()}</td></tr>
45 * <tr><td><code>project</code></td> <td></td>
46 * <td>{@link MavenSession#getCurrentProject()}</td></tr>
47 * <tr><td><code>project.*</code></td> <td></td> <td></td></tr>
48 * <tr><td><code>pom.*</code></td> <td>(since Maven 3)</td><td>same as <code>project.*</code></td></tr>
49 * <tr><td><code>executedProject</code></td> <td></td>
50 * <td>{@link MavenProject#getExecutionProject()}</td></tr>
51 * <tr><td><code>settings</code></td> <td></td> <td>{@link MavenSession#getSettings()}</td></tr>
52 * <tr><td><code>settings.*</code></td> <td></td> <td></td></tr>
53 * <tr><td><code>basedir</code></td> <td></td>
54 * <td>{@link MavenSession#getExecutionRootDirectory()} or
55 * <code>System.getProperty( "user.dir" )</code> if null</td></tr>
56 * <tr><td><code>mojoExecution</code></td> <td></td> <td>the actual {@link MojoExecution}</td></tr>
57 * <tr><td><code>mojo</code></td> <td>(since Maven 3)</td><td>same as <code>mojoExecution</code></td></tr>
58 * <tr><td><code>mojo.*</code></td> <td>(since Maven 3)</td><td></td></tr>
59 * <tr><td><code>plugin</code></td> <td>(since Maven 3)</td>
60 * <td>{@link MojoExecution#getMojoDescriptor()}.{@link MojoDescriptor#getPluginDescriptor()
61 * getPluginDescriptor()}</td></tr>
62 * <tr><td><code>plugin.*</code></td> <td></td> <td></td></tr>
63 * <tr><td><code>*</code></td> <td></td> <td>user properties</td></tr>
64 * <tr><td><code>*</code></td> <td></td> <td>project properties</td></tr>
65 * <tr><td><code>*</code></td> <td></td> <td>system properties</td></tr>
66 * </table>
67 * <i>Notice:</i> <code>reports</code> was supported in Maven 2.x but was removed in Maven 3
68 *
69 * @author Jason van Zyl
70 * @see MavenSession
71 * @see MojoExecution
72 */
73 public class PluginParameterExpressionEvaluator implements TypeAwareExpressionEvaluator {
74 private MavenSession session;
75
76 private MojoExecution mojoExecution;
77
78 private MavenProject project;
79
80 private String basedir;
81
82 private Properties properties;
83
84 public PluginParameterExpressionEvaluator(MavenSession session) {
85 this(session, null);
86 }
87
88 public PluginParameterExpressionEvaluator(MavenSession session, MojoExecution mojoExecution) {
89 this.session = session;
90 this.mojoExecution = mojoExecution;
91 this.properties = new Properties();
92 this.project = session.getCurrentProject();
93
94 //
95 // Maven4: We may want to evaluate how this is used but we add these separate as the
96 // getExecutionProperties is deprecated in MavenSession.
97 //
98 this.properties.putAll(session.getUserProperties());
99 this.properties.putAll(session.getSystemProperties());
100
101 String basedir = null;
102
103 if (project != null) {
104 File projectFile = project.getBasedir();
105
106 // this should always be the case for non-super POM instances...
107 if (projectFile != null) {
108 basedir = projectFile.getAbsolutePath();
109 }
110 }
111
112 if (basedir == null) {
113 basedir = session.getExecutionRootDirectory();
114 }
115
116 if (basedir == null) {
117 basedir = System.getProperty("user.dir");
118 }
119
120 this.basedir = basedir;
121 }
122
123 @Override
124 public Object evaluate(String expr) throws ExpressionEvaluationException {
125 return evaluate(expr, null);
126 }
127
128 @Override
129 @SuppressWarnings("checkstyle:methodlength")
130 public Object evaluate(String expr, Class<?> type) throws ExpressionEvaluationException {
131 Object value = null;
132
133 if (expr == null) {
134 return null;
135 }
136
137 String expression = stripTokens(expr);
138 if (expression.equals(expr)) {
139 int index = expr.indexOf("${");
140 if (index >= 0) {
141 int lastIndex = expr.indexOf('}', index);
142 if (lastIndex >= 0) {
143 String retVal = expr.substring(0, index);
144
145 if ((index > 0) && (expr.charAt(index - 1) == '$')) {
146 retVal += expr.substring(index + 1, lastIndex + 1);
147 } else {
148 Object subResult = evaluate(expr.substring(index, lastIndex + 1));
149
150 if (subResult != null) {
151 retVal += subResult;
152 } else {
153 retVal += "$" + expr.substring(index + 1, lastIndex + 1);
154 }
155 }
156
157 retVal += evaluate(expr.substring(lastIndex + 1));
158 return retVal;
159 }
160 }
161
162 // Was not an expression
163 return expression.replace("$$", "$");
164 }
165
166 MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
167
168 if ("localRepository".equals(expression)) {
169 value = session.getLocalRepository();
170 } else if ("session".equals(expression)) {
171 value = session;
172 } else if (expression.startsWith("session")) {
173 try {
174 int pathSeparator = expression.indexOf('/');
175
176 if (pathSeparator > 0) {
177 String pathExpression = expression.substring(1, pathSeparator);
178 value = ReflectionValueExtractor.evaluate(pathExpression, session);
179 value = value + expression.substring(pathSeparator);
180 } else {
181 value = ReflectionValueExtractor.evaluate(expression.substring(1), session);
182 }
183 } catch (Exception e) {
184 // TODO don't catch exception
185 throw new ExpressionEvaluationException(
186 "Error evaluating plugin parameter expression: " + expression, e);
187 }
188 } else if ("reactorProjects".equals(expression)) {
189 value = session.getProjects();
190 } else if ("project".equals(expression)) {
191 value = project;
192 } else if ("executedProject".equals(expression)) {
193 value = project.getExecutionProject();
194 } else if (expression.startsWith("project") || expression.startsWith("pom")) {
195 try {
196 int pathSeparator = expression.indexOf('/');
197
198 if (pathSeparator > 0) {
199 String pathExpression = expression.substring(0, pathSeparator);
200 value = ReflectionValueExtractor.evaluate(pathExpression, project);
201 value = value + expression.substring(pathSeparator);
202 } else {
203 value = ReflectionValueExtractor.evaluate(expression.substring(1), project);
204 }
205 } catch (Exception e) {
206 // TODO don't catch exception
207 throw new ExpressionEvaluationException(
208 "Error evaluating plugin parameter expression: " + expression, e);
209 }
210 } else if (expression.equals("repositorySystemSession")) {
211 value = session.getRepositorySession();
212 } else if (expression.equals("mojo") || expression.equals("mojoExecution")) {
213 value = mojoExecution;
214 } else if (expression.startsWith("mojo")) {
215 try {
216 int pathSeparator = expression.indexOf('/');
217
218 if (pathSeparator > 0) {
219 String pathExpression = expression.substring(1, pathSeparator);
220 value = ReflectionValueExtractor.evaluate(pathExpression, mojoExecution);
221 value = value + expression.substring(pathSeparator);
222 } else {
223 value = ReflectionValueExtractor.evaluate(expression.substring(1), mojoExecution);
224 }
225 } catch (Exception e) {
226 // TODO don't catch exception
227 throw new ExpressionEvaluationException(
228 "Error evaluating plugin parameter expression: " + expression, e);
229 }
230 } else if (expression.equals("plugin")) {
231 value = mojoDescriptor.getPluginDescriptor();
232 } else if (expression.startsWith("plugin")) {
233 try {
234 int pathSeparator = expression.indexOf('/');
235
236 PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
237
238 if (pathSeparator > 0) {
239 String pathExpression = expression.substring(1, pathSeparator);
240 value = ReflectionValueExtractor.evaluate(pathExpression, pluginDescriptor);
241 value = value + expression.substring(pathSeparator);
242 } else {
243 value = ReflectionValueExtractor.evaluate(expression.substring(1), pluginDescriptor);
244 }
245 } catch (Exception e) {
246 throw new ExpressionEvaluationException(
247 "Error evaluating plugin parameter expression: " + expression, e);
248 }
249 } else if ("settings".equals(expression)) {
250 value = session.getSettings();
251 } else if (expression.startsWith("settings")) {
252 try {
253 int pathSeparator = expression.indexOf('/');
254
255 if (pathSeparator > 0) {
256 String pathExpression = expression.substring(1, pathSeparator);
257 value = ReflectionValueExtractor.evaluate(pathExpression, session.getSettings());
258 value = value + expression.substring(pathSeparator);
259 } else {
260 value = ReflectionValueExtractor.evaluate(expression.substring(1), session.getSettings());
261 }
262 } catch (Exception e) {
263 // TODO don't catch exception
264 throw new ExpressionEvaluationException(
265 "Error evaluating plugin parameter expression: " + expression, e);
266 }
267 } else if ("basedir".equals(expression)) {
268 value = basedir;
269 } else if (expression.startsWith("basedir")) {
270 int pathSeparator = expression.indexOf('/');
271
272 if (pathSeparator > 0) {
273 value = basedir + expression.substring(pathSeparator);
274 }
275 }
276
277 /*
278 * MNG-4312: We neither have reserved all of the above magic expressions nor is their set fixed/well-known (it
279 * gets occasionally extended by newer Maven versions). This imposes the risk for existing plugins to
280 * unintentionally use such a magic expression for an ordinary property. So here we check whether we
281 * ended up with a magic value that is not compatible with the type of the configured mojo parameter (a string
282 * could still be converted by the configurator so we leave those alone). If so, back off to evaluating the
283 * expression from properties only.
284 */
285 if (value != null && type != null && !(value instanceof String) && !isTypeCompatible(type, value)) {
286 value = null;
287 }
288
289 if (value == null) {
290 // The CLI should win for defining properties
291
292 if (properties != null) {
293 // We will attempt to get nab a property as a way to specify a parameter
294 // to a plugin. My particular case here is allowing the surefire plugin
295 // to run a single test so I want to specify that class on the cli as
296 // a parameter.
297
298 value = properties.getProperty(expression);
299 }
300
301 if ((value == null) && ((project != null) && (project.getProperties() != null))) {
302 value = project.getProperties().getProperty(expression);
303 }
304 }
305
306 if (value instanceof String) {
307 // TODO without #, this could just be an evaluate call...
308
309 String val = (String) value;
310
311 int exprStartDelimiter = val.indexOf("${");
312
313 if (exprStartDelimiter >= 0) {
314 if (exprStartDelimiter > 0) {
315 value = val.substring(0, exprStartDelimiter) + evaluate(val.substring(exprStartDelimiter));
316 } else {
317 value = evaluate(val.substring(exprStartDelimiter));
318 }
319 }
320 }
321
322 return value;
323 }
324
325 private static boolean isTypeCompatible(Class<?> type, Object value) {
326 if (type.isInstance(value)) {
327 return true;
328 }
329 // likely Boolean -> boolean, Short -> int etc. conversions, it's not the problem case we try to avoid
330 return ((type.isPrimitive() || type.getName().startsWith("java.lang."))
331 && value.getClass().getName().startsWith("java.lang."));
332 }
333
334 private String stripTokens(String expr) {
335 if (expr.startsWith("${") && (expr.indexOf('}') == expr.length() - 1)) {
336 expr = expr.substring(2, expr.length() - 1);
337 }
338 return expr;
339 }
340
341 @Override
342 public File alignToBaseDirectory(File file) {
343 // TODO Copied from the DefaultInterpolator. We likely want to resurrect the PathTranslator or at least a
344 // similar component for re-usage
345 if (file != null) {
346 if (file.isAbsolute()) {
347 // path was already absolute, just normalize file separator and we're done
348 } else if (file.getPath().startsWith(File.separator)) {
349 // drive-relative Windows path, don't align with project directory but with drive root
350 file = file.getAbsoluteFile();
351 } else {
352 // an ordinary relative path, align with project directory
353 file = new File(new File(basedir, file.getPath()).toURI().normalize()).getAbsoluteFile();
354 }
355 }
356 return file;
357 }
358 }