src/main/java/org/apache/maven/plugins/help/EvaluateMojo.java - maven-help-plugin - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.maven.plugins.help;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StringWriter;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.TreeMap;
 import java.util.jar.JarEntry;
 import java.util.jar.JarInputStream;

 import com.thoughtworks.xstream.XStream;
 import com.thoughtworks.xstream.converters.MarshallingContext;
 import com.thoughtworks.xstream.converters.collections.PropertiesConverter;
 import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
 import org.apache.maven.lifecycle.internal.MojoDescriptorCreator;
 import org.apache.maven.model.Dependency;
 import org.apache.maven.model.Model;
 import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
 import org.apache.maven.plugin.MojoExecution;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugin.PluginParameterExpressionEvaluator;
 import org.apache.maven.plugin.descriptor.MojoDescriptor;
 import org.apache.maven.plugins.annotations.Component;
 import org.apache.maven.plugins.annotations.Mojo;
 import org.apache.maven.plugins.annotations.Parameter;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.settings.Settings;
 import org.apache.maven.settings.io.xpp3.SettingsXpp3Writer;
 import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
 import org.codehaus.plexus.components.interactivity.InputHandler;
 import org.codehaus.plexus.util.StringUtils;
 import org.eclipse.aether.RepositoryException;
 import org.eclipse.aether.artifact.Artifact;
 import org.eclipse.aether.artifact.DefaultArtifact;

 /**
  * Evaluates Maven expressions given by the user in an interactive mode.
  *
  * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
  * @since 2.1
  */
 @Mojo(name = "evaluate", requiresProject = false)
 public class EvaluateMojo extends AbstractHelpMojo {
     // ----------------------------------------------------------------------
     // Mojo components
     // ----------------------------------------------------------------------

     /**
      * Input handler, needed for command line handling.
      */
     @Component
     private InputHandler inputHandler;

     /**
      * Component used to get mojo descriptors.
      */
     @Component
     private MojoDescriptorCreator mojoDescriptorCreator;

     // ----------------------------------------------------------------------
     // Mojo parameters
     // ----------------------------------------------------------------------

     // we need to hide the 'output' defined in AbstractHelpMojo to have a correct "since".
     /**
      * Optional parameter to write the output of this help in a given file, instead of writing to the console.
      * This parameter will be ignored if no <code>expression</code> is specified.
      * <br/>
      * <b>Note</b>: Could be a relative path.
      *
      * @since 3.0.0
      */
     @Parameter(property = "output")
     private File output;

     /**
      * This options gives the option to output information in cases where the output has been suppressed by using
      * <code>-q</code> (quiet option) in Maven. This is useful if you like to use
      * <code>maven-help-plugin:evaluate</code> in a script call (for example in bash) like this:
      *
      * <pre>
      * RESULT=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)
      * echo $RESULT
      * </pre>
      *
      * This will only printout the information which has been requested by <code>expression</code> to
      * <code>stdout</code>.
      *
      * @since 3.1.0
      */
     @Parameter(property = "forceStdout", defaultValue = "false")
     private boolean forceStdout;

     /**
      * An artifact for evaluating Maven expressions. <br/>
      * <b>Note</b>: Should respect the Maven format, i.e. <code>groupId:artifactId[:version]</code>. The latest version
      * of the artifact will be used when no version is specified.
      */
     @Parameter(property = "artifact")
     private String artifact;

     /**
      * An expression to evaluate instead of prompting. Note that this <i>must not</i> include the surrounding ${...}.
      */
     @Parameter(property = "expression")
     private String expression;

     /**
      * The system settings for Maven.
      */
     @Parameter(defaultValue = "${settings}", readonly = true, required = true)
     private Settings settings;

     // ----------------------------------------------------------------------
     // Instance variables
     // ----------------------------------------------------------------------

     /** lazy loading evaluator variable */
     private PluginParameterExpressionEvaluator evaluator;

     /** lazy loading xstream variable */
     private XStream xstream;

     // ----------------------------------------------------------------------
     // Public methods
     // ----------------------------------------------------------------------

     /** {@inheritDoc} */
     public void execute() throws MojoExecutionException, MojoFailureException {
         if (expression == null && !settings.isInteractiveMode()) {

             getLog().error("Maven is configured to NOT interact with the user for input. "
                     + "This Mojo requires that 'interactiveMode' in your settings file is flag to 'true'.");
             return;
         }

         validateParameters();

         if (artifact != null && !artifact.isEmpty()) {
             project = getMavenProject(artifact);
         }

         if (expression == null) {
             if (output != null) {
                 getLog().warn("When prompting for input, the result will be written to the console, "
                         + "ignoring 'output'.");
             }
             while (true) {
                 getLog().info("Enter the Maven expression i.e. ${project.groupId} or 0 to exit?:");

                 try {
                     String userExpression = inputHandler.readLine();
                     if (userExpression == null
                             || userExpression.toLowerCase(Locale.ENGLISH).equals("0")) {
                         break;
                     }

                     handleResponse(userExpression, null);
                 } catch (IOException e) {
                     throw new MojoExecutionException("Unable to read from standard input.", e);
                 }
             }
         } else {
             handleResponse("${" + expression + "}", output);
         }
     }

     // ----------------------------------------------------------------------
     // Private methods
     // ----------------------------------------------------------------------

     /**
      * Validate Mojo parameters.
      */
     private void validateParameters() {
         if (artifact == null) {
             // using project if found or super-pom
             getLog().info("No artifact parameter specified, using '" + project.getId() + "' as project.");
         }
     }

     /**
      * @return a lazy loading evaluator object.
      * @throws MojoFailureException if any reflection exceptions occur or missing components.
      */
     private PluginParameterExpressionEvaluator getEvaluator() throws MojoFailureException {
         if (evaluator == null) {
             MojoDescriptor mojoDescriptor;
             try {
                 mojoDescriptor = mojoDescriptorCreator.getMojoDescriptor("help:evaluate", session, project);
             } catch (Exception e) {
                 throw new MojoFailureException("Failure while evaluating.", e);
             }
             MojoExecution mojoExecution = new MojoExecution(mojoDescriptor);

             MavenProject currentProject = session.getCurrentProject();
             // Maven 3: PluginParameterExpressionEvaluator gets the current project from the session:
             // synchronize in case another thread wants to fetch the real current project in between
             synchronized (session) {
                 session.setCurrentProject(project);
                 evaluator = new PluginParameterExpressionEvaluator(session, mojoExecution);
                 session.setCurrentProject(currentProject);
             }
         }

         return evaluator;
     }

     /**
      * @param expr the user expression asked.
      * @param output the file where to write the result, or <code>null</code> to print in standard output.
      * @throws MojoExecutionException if any
      * @throws MojoFailureException if any reflection exceptions occur or missing components.
      */
     private void handleResponse(String expr, File output) throws MojoExecutionException, MojoFailureException {
         StringBuilder response = new StringBuilder();

         Object obj;
         try {
             obj = getEvaluator().evaluate(expr);
         } catch (ExpressionEvaluationException e) {
             throw new MojoExecutionException("Error when evaluating the Maven expression", e);
         }

         if (obj != null && expr.equals(obj.toString())) {
             getLog().warn("The Maven expression was invalid. Please use a valid expression.");
             return;
         }

         // handle null
         if (obj == null) {
             response.append("null object or invalid expression");
         }
         // handle primitives objects
         else if (obj instanceof String) {
             response.append(obj.toString());
         } else if (obj instanceof Boolean) {
             response.append(obj.toString());
         } else if (obj instanceof Byte) {
             response.append(obj.toString());
         } else if (obj instanceof Character) {
             response.append(obj.toString());
         } else if (obj instanceof Double) {
             response.append(obj.toString());
         } else if (obj instanceof Float) {
             response.append(obj.toString());
         } else if (obj instanceof Integer) {
             response.append(obj.toString());
         } else if (obj instanceof Long) {
             response.append(obj.toString());
         } else if (obj instanceof Short) {
             response.append(obj.toString());
         }
         // handle specific objects
         else if (obj instanceof File) {
             File f = (File) obj;
             response.append(f.getAbsolutePath());
         }
         // handle Maven pom object
         else if (obj instanceof MavenProject) {
             MavenProject projectAsked = (MavenProject) obj;
             StringWriter sWriter = new StringWriter();
             MavenXpp3Writer pomWriter = new MavenXpp3Writer();
             try {
                 pomWriter.write(sWriter, projectAsked.getModel());
             } catch (IOException e) {
                 throw new MojoExecutionException("Error when writing pom", e);
             }

             response.append(sWriter.toString());
         }
         // handle Maven Settings object
         else if (obj instanceof Settings) {
             Settings settingsAsked = (Settings) obj;
             StringWriter sWriter = new StringWriter();
             SettingsXpp3Writer settingsWriter = new SettingsXpp3Writer();
             try {
                 settingsWriter.write(sWriter, settingsAsked);
             } catch (IOException e) {
                 throw new MojoExecutionException("Error when writing settings", e);
             }

             response.append(sWriter.toString());
         } else {
             // others Maven objects
             response.append(toXML(expr, obj));
         }

         if (output != null) {
             try {
                 writeFile(output, response);
             } catch (IOException e) {
                 throw new MojoExecutionException("Cannot write evaluation of expression to output: " + output, e);
             }
             getLog().info("Result of evaluation written to: " + output);
         } else {
             if (getLog().isInfoEnabled()) {
                 getLog().info(LS + response.toString());
             } else {
                 if (forceStdout) {
                     System.out.print(response.toString());
                     System.out.flush();
                 }
             }
         }
     }

     /**
      * @param expr the user expression.
      * @param obj a not null.
      * @return the XML for the given object.
      */
     private String toXML(String expr, Object obj) {
         XStream currentXStream = getXStream();

         // beautify list
         if (obj instanceof List) {
             List<?> list = (List<?>) obj;
             if (!list.isEmpty()) {
                 Object elt = list.iterator().next();

                 String name = StringUtils.lowercaseFirstLetter(elt.getClass().getSimpleName());
                 currentXStream.alias(pluralize(name), List.class);
             } else {
                 // try to detect the alias from question
                 if (expr.indexOf('.') != -1) {
                     String name = expr.substring(expr.indexOf('.') + 1, expr.indexOf('}'));
                     currentXStream.alias(name, List.class);
                 }
             }
         }

         return currentXStream.toXML(obj);
     }

     /**
      * @return lazy loading xstream object.
      */
     private XStream getXStream() {
         if (xstream == null) {
             xstream = new XStream();
             addAlias(xstream);

             // handle Properties a la Maven
             xstream.registerConverter(new PropertiesConverter() {
                 /** {@inheritDoc} */
                 @Override
                 public boolean canConvert(Class type) {
                     return Properties.class == type;
                 }

                 /** {@inheritDoc} */
                 @Override
                 public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
                     Properties properties = (Properties) source;
                     Map<?, ?> map = new TreeMap<>(properties); // sort
                     for (Map.Entry<?, ?> entry : map.entrySet()) {
                         writer.startNode(entry.getKey().toString());
                         writer.setValue(entry.getValue().toString());
                         writer.endNode();
                     }
                 }
             });
         }

         return xstream;
     }

     /**
      * @param xstreamObject not null
      */
     private void addAlias(XStream xstreamObject) {
         try {
             addAlias(xstreamObject, getArtifactFile("maven-model"), "org.apache.maven.model");
             addAlias(xstreamObject, getArtifactFile("maven-settings"), "org.apache.maven.settings");
         } catch (MojoExecutionException | RepositoryException e) {
             if (getLog().isDebugEnabled()) {
                 getLog().debug(e.getMessage(), e);
             }
         }

         // TODO need to handle specific Maven objects like DefaultArtifact?
     }

     /**
      * @param xstreamObject not null
      * @param jarFile not null
      * @param packageFilter a package name to filter.
      */
     private void addAlias(XStream xstreamObject, File jarFile, String packageFilter) {
         try (FileInputStream fis = new FileInputStream(jarFile);
                 JarInputStream jarStream = new JarInputStream(fis)) {
             for (JarEntry jarEntry = jarStream.getNextJarEntry();
                     jarEntry != null;
                     jarEntry = jarStream.getNextJarEntry()) {
                 if (jarEntry.getName().toLowerCase(Locale.ENGLISH).endsWith(".class")) {
                     String name =
                             jarEntry.getName().substring(0, jarEntry.getName().indexOf("."));
                     name = name.replace("/", "\\.");

                     if (name.contains(packageFilter) && !name.contains("$")) {
                         try {
                             Class<?> clazz = Class.forName(name);
                             String alias = StringUtils.lowercaseFirstLetter(clazz.getSimpleName());
                             xstreamObject.alias(alias, clazz);
                             if (!clazz.equals(Model.class)) {
                                 xstreamObject.omitField(clazz, "modelEncoding"); // unnecessary field
                             }
                         } catch (ClassNotFoundException e) {
                             getLog().error(e);
                         }
                     }
                 }

                 jarStream.closeEntry();
             }
         } catch (IOException e) {
             if (getLog().isDebugEnabled()) {
                 getLog().debug("IOException: " + e.getMessage(), e);
             }
         }
     }

     /**
      * @return the <code>org.apache.maven: artifactId </code> artifact jar file for this current HelpPlugin pom.
      * @throws MojoExecutionException if any
      */
     private File getArtifactFile(String artifactId) throws MojoExecutionException, RepositoryException {
         List<Dependency> dependencies = getHelpPluginPom().getDependencies();
         for (Dependency dependency : dependencies) {
             if ("org.apache.maven".equals(dependency.getGroupId())) {
                 if (artifactId.equals(dependency.getArtifactId())) {
                     Artifact mavenArtifact = new DefaultArtifact(
                             dependency.getGroupId(), dependency.getArtifactId(), "jar", dependency.getVersion());

                     return resolveArtifact(mavenArtifact).getArtifact().getFile();
                 }
             }
         }

         throw new MojoExecutionException("Unable to find the 'org.apache.maven:" + artifactId + "' artifact");
     }

     /**
      * @return the Maven POM for the current help plugin
      * @throws MojoExecutionException if any
      */
     private MavenProject getHelpPluginPom() throws MojoExecutionException {
         String resource = "META-INF/maven/org.apache.maven.plugins/maven-help-plugin/pom.properties";

         InputStream resourceAsStream = EvaluateMojo.class.getClassLoader().getResourceAsStream(resource);
         if (resourceAsStream == null) {
             throw new MojoExecutionException("The help plugin artifact was not found.");
         }
         Properties properties = new Properties();
         try (InputStream is = resourceAsStream) {
             properties.load(is);
         } catch (IOException e) {
             if (getLog().isDebugEnabled()) {
                 getLog().debug("IOException: " + e.getMessage(), e);
             }
         }

         String artifactString = properties.getProperty("groupId", "unknown") + ":"
                 + properties.getProperty("artifactId", "unknown") + ":"
                 + properties.getProperty("version", "unknown");

         return getMavenProject(artifactString);
     }

     /**
      * @param name not null
      * @return the plural of the name
      */
     private static String pluralize(String name) {
         if (name == null || name.isEmpty()) {
             throw new IllegalArgumentException("name is required");
         }

         if (name.endsWith("y")) {
             return name.substring(0, name.length() - 1) + "ies";
         } else if (name.endsWith("s")) {
             return name;
         } else {
             return name + "s";
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.maven.plugins.help;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.StringWriter;
	import java.util.List;
	import java.util.Locale;
	import java.util.Map;
	import java.util.Properties;
	import java.util.TreeMap;
	import java.util.jar.JarEntry;
	import java.util.jar.JarInputStream;

	import com.thoughtworks.xstream.XStream;
	import com.thoughtworks.xstream.converters.MarshallingContext;
	import com.thoughtworks.xstream.converters.collections.PropertiesConverter;
	import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
	import org.apache.maven.lifecycle.internal.MojoDescriptorCreator;
	import org.apache.maven.model.Dependency;
	import org.apache.maven.model.Model;
	import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
	import org.apache.maven.plugin.MojoExecution;
	import org.apache.maven.plugin.MojoExecutionException;
	import org.apache.maven.plugin.MojoFailureException;
	import org.apache.maven.plugin.PluginParameterExpressionEvaluator;
	import org.apache.maven.plugin.descriptor.MojoDescriptor;
	import org.apache.maven.plugins.annotations.Component;
	import org.apache.maven.plugins.annotations.Mojo;
	import org.apache.maven.plugins.annotations.Parameter;
	import org.apache.maven.project.MavenProject;
	import org.apache.maven.settings.Settings;
	import org.apache.maven.settings.io.xpp3.SettingsXpp3Writer;
	import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
	import org.codehaus.plexus.components.interactivity.InputHandler;
	import org.codehaus.plexus.util.StringUtils;
	import org.eclipse.aether.RepositoryException;
	import org.eclipse.aether.artifact.Artifact;
	import org.eclipse.aether.artifact.DefaultArtifact;

	/**
	* Evaluates Maven expressions given by the user in an interactive mode.
	*
	* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
	* @since 2.1
	*/
	@Mojo(name = "evaluate", requiresProject = false)
	public class EvaluateMojo extends AbstractHelpMojo {
	// ----------------------------------------------------------------------
	// Mojo components
	// ----------------------------------------------------------------------

	/**
	* Input handler, needed for command line handling.
	*/
	@Component
	private InputHandler inputHandler;

	/**
	* Component used to get mojo descriptors.
	*/
	@Component
	private MojoDescriptorCreator mojoDescriptorCreator;

	// ----------------------------------------------------------------------
	// Mojo parameters
	// ----------------------------------------------------------------------

	// we need to hide the 'output' defined in AbstractHelpMojo to have a correct "since".
	/**
	* Optional parameter to write the output of this help in a given file, instead of writing to the console.
	* This parameter will be ignored if no <code>expression</code> is specified.
	* <br/>
	* <b>Note</b>: Could be a relative path.
	*
	* @since 3.0.0
	*/
	@Parameter(property = "output")
	private File output;

	/**
	* This options gives the option to output information in cases where the output has been suppressed by using
	* <code>-q</code> (quiet option) in Maven. This is useful if you like to use
	* <code>maven-help-plugin:evaluate</code> in a script call (for example in bash) like this:
	*
	* <pre>
	* RESULT=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)
	* echo $RESULT
	* </pre>
	*
	* This will only printout the information which has been requested by <code>expression</code> to
	* <code>stdout</code>.
	*
	* @since 3.1.0
	*/
	@Parameter(property = "forceStdout", defaultValue = "false")
	private boolean forceStdout;

	/**
	* An artifact for evaluating Maven expressions. <br/>
	* <b>Note</b>: Should respect the Maven format, i.e. <code>groupId:artifactId[:version]</code>. The latest version
	* of the artifact will be used when no version is specified.
	*/
	@Parameter(property = "artifact")
	private String artifact;

	/**
	* An expression to evaluate instead of prompting. Note that this <i>must not</i> include the surrounding ${...}.
	*/
	@Parameter(property = "expression")
	private String expression;

	/**
	* The system settings for Maven.
	*/
	@Parameter(defaultValue = "${settings}", readonly = true, required = true)
	private Settings settings;

	// ----------------------------------------------------------------------
	// Instance variables
	// ----------------------------------------------------------------------

	/** lazy loading evaluator variable */
	private PluginParameterExpressionEvaluator evaluator;

	/** lazy loading xstream variable */
	private XStream xstream;

	// ----------------------------------------------------------------------
	// Public methods
	// ----------------------------------------------------------------------

	/** {@inheritDoc} */
	public void execute() throws MojoExecutionException, MojoFailureException {
	if (expression == null && !settings.isInteractiveMode()) {

	getLog().error("Maven is configured to NOT interact with the user for input. "
	+ "This Mojo requires that 'interactiveMode' in your settings file is flag to 'true'.");
	return;
	}

	validateParameters();

	if (artifact != null && !artifact.isEmpty()) {
	project = getMavenProject(artifact);
	}

	if (expression == null) {
	if (output != null) {
	getLog().warn("When prompting for input, the result will be written to the console, "
	+ "ignoring 'output'.");
	}
	while (true) {
	getLog().info("Enter the Maven expression i.e. ${project.groupId} or 0 to exit?:");

	try {
	String userExpression = inputHandler.readLine();
	if (userExpression == null
	\|\| userExpression.toLowerCase(Locale.ENGLISH).equals("0")) {
	break;
	}

	handleResponse(userExpression, null);
	} catch (IOException e) {
	throw new MojoExecutionException("Unable to read from standard input.", e);
	}
	}
	} else {
	handleResponse("${" + expression + "}", output);
	}
	}

	// ----------------------------------------------------------------------
	// Private methods
	// ----------------------------------------------------------------------

	/**
	* Validate Mojo parameters.
	*/
	private void validateParameters() {
	if (artifact == null) {
	// using project if found or super-pom
	getLog().info("No artifact parameter specified, using '" + project.getId() + "' as project.");
	}
	}

	/**
	* @return a lazy loading evaluator object.
	* @throws MojoFailureException if any reflection exceptions occur or missing components.
	*/
	private PluginParameterExpressionEvaluator getEvaluator() throws MojoFailureException {
	if (evaluator == null) {
	MojoDescriptor mojoDescriptor;
	try {
	mojoDescriptor = mojoDescriptorCreator.getMojoDescriptor("help:evaluate", session, project);
	} catch (Exception e) {
	throw new MojoFailureException("Failure while evaluating.", e);
	}
	MojoExecution mojoExecution = new MojoExecution(mojoDescriptor);

	MavenProject currentProject = session.getCurrentProject();
	// Maven 3: PluginParameterExpressionEvaluator gets the current project from the session:
	// synchronize in case another thread wants to fetch the real current project in between
	synchronized (session) {
	session.setCurrentProject(project);
	evaluator = new PluginParameterExpressionEvaluator(session, mojoExecution);
	session.setCurrentProject(currentProject);
	}
	}

	return evaluator;
	}

	/**
	* @param expr the user expression asked.
	* @param output the file where to write the result, or <code>null</code> to print in standard output.
	* @throws MojoExecutionException if any
	* @throws MojoFailureException if any reflection exceptions occur or missing components.
	*/
	private void handleResponse(String expr, File output) throws MojoExecutionException, MojoFailureException {
	StringBuilder response = new StringBuilder();

	Object obj;
	try {
	obj = getEvaluator().evaluate(expr);
	} catch (ExpressionEvaluationException e) {
	throw new MojoExecutionException("Error when evaluating the Maven expression", e);
	}

	if (obj != null && expr.equals(obj.toString())) {
	getLog().warn("The Maven expression was invalid. Please use a valid expression.");
	return;
	}

	// handle null
	if (obj == null) {
	response.append("null object or invalid expression");
	}
	// handle primitives objects
	else if (obj instanceof String) {
	response.append(obj.toString());
	} else if (obj instanceof Boolean) {
	response.append(obj.toString());
	} else if (obj instanceof Byte) {
	response.append(obj.toString());
	} else if (obj instanceof Character) {
	response.append(obj.toString());
	} else if (obj instanceof Double) {
	response.append(obj.toString());
	} else if (obj instanceof Float) {
	response.append(obj.toString());
	} else if (obj instanceof Integer) {
	response.append(obj.toString());
	} else if (obj instanceof Long) {
	response.append(obj.toString());
	} else if (obj instanceof Short) {
	response.append(obj.toString());
	}
	// handle specific objects
	else if (obj instanceof File) {
	File f = (File) obj;
	response.append(f.getAbsolutePath());
	}
	// handle Maven pom object
	else if (obj instanceof MavenProject) {
	MavenProject projectAsked = (MavenProject) obj;
	StringWriter sWriter = new StringWriter();
	MavenXpp3Writer pomWriter = new MavenXpp3Writer();
	try {
	pomWriter.write(sWriter, projectAsked.getModel());
	} catch (IOException e) {
	throw new MojoExecutionException("Error when writing pom", e);
	}

	response.append(sWriter.toString());
	}
	// handle Maven Settings object
	else if (obj instanceof Settings) {
	Settings settingsAsked = (Settings) obj;
	StringWriter sWriter = new StringWriter();
	SettingsXpp3Writer settingsWriter = new SettingsXpp3Writer();
	try {
	settingsWriter.write(sWriter, settingsAsked);
	} catch (IOException e) {
	throw new MojoExecutionException("Error when writing settings", e);
	}

	response.append(sWriter.toString());
	} else {
	// others Maven objects
	response.append(toXML(expr, obj));
	}

	if (output != null) {
	try {
	writeFile(output, response);
	} catch (IOException e) {
	throw new MojoExecutionException("Cannot write evaluation of expression to output: " + output, e);
	}
	getLog().info("Result of evaluation written to: " + output);
	} else {
	if (getLog().isInfoEnabled()) {
	getLog().info(LS + response.toString());
	} else {
	if (forceStdout) {
	System.out.print(response.toString());
	System.out.flush();
	}
	}
	}
	}

	/**
	* @param expr the user expression.
	* @param obj a not null.
	* @return the XML for the given object.
	*/
	private String toXML(String expr, Object obj) {
	XStream currentXStream = getXStream();

	// beautify list
	if (obj instanceof List) {
	List<?> list = (List<?>) obj;
	if (!list.isEmpty()) {
	Object elt = list.iterator().next();

	String name = StringUtils.lowercaseFirstLetter(elt.getClass().getSimpleName());
	currentXStream.alias(pluralize(name), List.class);
	} else {
	// try to detect the alias from question
	if (expr.indexOf('.') != -1) {
	String name = expr.substring(expr.indexOf('.') + 1, expr.indexOf('}'));
	currentXStream.alias(name, List.class);
	}
	}
	}

	return currentXStream.toXML(obj);
	}

	/**
	* @return lazy loading xstream object.
	*/
	private XStream getXStream() {
	if (xstream == null) {
	xstream = new XStream();
	addAlias(xstream);

	// handle Properties a la Maven
	xstream.registerConverter(new PropertiesConverter() {
	/** {@inheritDoc} */
	@Override
	public boolean canConvert(Class type) {
	return Properties.class == type;
	}

	/** {@inheritDoc} */
	@Override
	public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
	Properties properties = (Properties) source;
	Map<?, ?> map = new TreeMap<>(properties); // sort
	for (Map.Entry<?, ?> entry : map.entrySet()) {
	writer.startNode(entry.getKey().toString());
	writer.setValue(entry.getValue().toString());
	writer.endNode();
	}
	}
	});
	}

	return xstream;
	}

	/**
	* @param xstreamObject not null
	*/
	private void addAlias(XStream xstreamObject) {
	try {
	addAlias(xstreamObject, getArtifactFile("maven-model"), "org.apache.maven.model");
	addAlias(xstreamObject, getArtifactFile("maven-settings"), "org.apache.maven.settings");
	} catch (MojoExecutionException \| RepositoryException e) {
	if (getLog().isDebugEnabled()) {
	getLog().debug(e.getMessage(), e);
	}
	}

	// TODO need to handle specific Maven objects like DefaultArtifact?
	}

	/**
	* @param xstreamObject not null
	* @param jarFile not null
	* @param packageFilter a package name to filter.
	*/
	private void addAlias(XStream xstreamObject, File jarFile, String packageFilter) {
	try (FileInputStream fis = new FileInputStream(jarFile);
	JarInputStream jarStream = new JarInputStream(fis)) {
	for (JarEntry jarEntry = jarStream.getNextJarEntry();
	jarEntry != null;
	jarEntry = jarStream.getNextJarEntry()) {
	if (jarEntry.getName().toLowerCase(Locale.ENGLISH).endsWith(".class")) {
	String name =
	jarEntry.getName().substring(0, jarEntry.getName().indexOf("."));
	name = name.replace("/", "\\.");

	if (name.contains(packageFilter) && !name.contains("$")) {
	try {
	Class<?> clazz = Class.forName(name);
	String alias = StringUtils.lowercaseFirstLetter(clazz.getSimpleName());
	xstreamObject.alias(alias, clazz);
	if (!clazz.equals(Model.class)) {
	xstreamObject.omitField(clazz, "modelEncoding"); // unnecessary field
	}
	} catch (ClassNotFoundException e) {
	getLog().error(e);
	}
	}
	}

	jarStream.closeEntry();
	}
	} catch (IOException e) {
	if (getLog().isDebugEnabled()) {
	getLog().debug("IOException: " + e.getMessage(), e);
	}
	}
	}

	/**
	* @return the <code>org.apache.maven: artifactId </code> artifact jar file for this current HelpPlugin pom.
	* @throws MojoExecutionException if any
	*/
	private File getArtifactFile(String artifactId) throws MojoExecutionException, RepositoryException {
	List<Dependency> dependencies = getHelpPluginPom().getDependencies();
	for (Dependency dependency : dependencies) {
	if ("org.apache.maven".equals(dependency.getGroupId())) {
	if (artifactId.equals(dependency.getArtifactId())) {
	Artifact mavenArtifact = new DefaultArtifact(
	dependency.getGroupId(), dependency.getArtifactId(), "jar", dependency.getVersion());

	return resolveArtifact(mavenArtifact).getArtifact().getFile();
	}
	}
	}

	throw new MojoExecutionException("Unable to find the 'org.apache.maven:" + artifactId + "' artifact");
	}

	/**
	* @return the Maven POM for the current help plugin
	* @throws MojoExecutionException if any
	*/
	private MavenProject getHelpPluginPom() throws MojoExecutionException {
	String resource = "META-INF/maven/org.apache.maven.plugins/maven-help-plugin/pom.properties";

	InputStream resourceAsStream = EvaluateMojo.class.getClassLoader().getResourceAsStream(resource);
	if (resourceAsStream == null) {
	throw new MojoExecutionException("The help plugin artifact was not found.");
	}
	Properties properties = new Properties();
	try (InputStream is = resourceAsStream) {
	properties.load(is);
	} catch (IOException e) {
	if (getLog().isDebugEnabled()) {
	getLog().debug("IOException: " + e.getMessage(), e);
	}
	}

	String artifactString = properties.getProperty("groupId", "unknown") + ":"
	+ properties.getProperty("artifactId", "unknown") + ":"
	+ properties.getProperty("version", "unknown");

	return getMavenProject(artifactString);
	}

	/**
	* @param name not null
	* @return the plural of the name
	*/
	private static String pluralize(String name) {
	if (name == null \|\| name.isEmpty()) {
	throw new IllegalArgumentException("name is required");
	}

	if (name.endsWith("y")) {
	return name.substring(0, name.length() - 1) + "ies";
	} else if (name.endsWith("s")) {
	return name;
	} else {
	return name + "s";
	}
	}
	}