Java ExpressionEvaluator.evaluate方法代码示例

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm realm)
        throws ComponentConfigurationException {
    List<String> runtimeClasspathElements;
    try {
        // noinspection unchecked
        runtimeClasspathElements = (List<String>) expressionEvaluator
                .evaluate("${project.runtimeClasspathElements}");
    } catch (ExpressionEvaluationException e) {
        throw new ComponentConfigurationException(
                "There was a problem evaluating: ${project.runtimeClasspathElements}", e);
    }

    // Add the project dependencies to the ClassRealm
    final URL[] urls = buildUrls(runtimeClasspathElements);
    for (URL url : urls) {
        realm.addURL(url);
    }
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private Collection<URL> buildAritfactDependencies(ExpressionEvaluator expressionEvaluator)
    throws ComponentConfigurationException
{
  MavenProject project;
  try
  {
    project = (MavenProject) expressionEvaluator.evaluate("${project}");
  }
  catch (ExpressionEvaluationException e1)
  {
    throw new ComponentConfigurationException("There was a problem evaluating: ${project}", e1);
  }
  Collection<URL> urls = new ArrayList<URL>();
  for (Object a : project.getArtifacts())
  {
    try
    {
      urls.add(((Artifact) a).getFile().toURI().toURL());
    }
    catch (MalformedURLException e)
    {
      throw new ComponentConfigurationException("Unable to resolve artifact dependency: " + a, e);
    }
  }
  return urls;
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private Collection<URL> buildAritfactDependencies(ExpressionEvaluator expressionEvaluator) throws ComponentConfigurationException {
    MavenProject project;
    try {
        project = (MavenProject) expressionEvaluator.evaluate("${project}");
    } catch (ExpressionEvaluationException e1) {
        throw new ComponentConfigurationException("There was a problem evaluating: ${project}", e1);
    }
    Collection<URL> urls = new ArrayList<URL>();
    for (Object a : project.getArtifacts()) {
        try {
            urls.add(((Artifact) a).getFile().toURI().toURL());
        } catch (MalformedURLException e) {
            throw new ComponentConfigurationException("Unable to resolve artifact dependency: " + a, e);
        }
    }
    return urls;
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm)
        throws ComponentConfigurationException
{
    List<String> runtimeClasspathElements;
    try
    {
        // noinspection unchecked
        runtimeClasspathElements = (List<String>) expressionEvaluator
                .evaluate("${project.runtimeClasspathElements}");
    }
    catch (ExpressionEvaluationException e)
    {
        throw new ComponentConfigurationException(
                "There was a problem evaluating: ${project.runtimeClasspathElements}", e);
    }

    // Add the project dependencies to the ClassRealm
    final URL[] urls = buildURLs(runtimeClasspathElements);
    for (URL url : urls)
    {
        containerRealm.addConstituent(url);
    }
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testValueExtractionWithAPomValueContainingAPath()
    throws Exception
{
    String expected = getTestFile( "target/test-classes/target/classes" ).getCanonicalPath();

    Build build = new Build();
    build.setDirectory( expected.substring( 0, expected.length() - "/classes".length() ) );

    Model model = new Model();
    model.setBuild( build );

    MavenProject project = new MavenProject( model );
    project.setFile( new File( "pom.xml" ).getCanonicalFile() );

    ExpressionEvaluator expressionEvaluator = createExpressionEvaluator( project, null, new Properties() );

    Object value = expressionEvaluator.evaluate( "${project.build.directory}/classes" );
    String actual = new File( value.toString() ).getCanonicalPath();

    assertEquals( expected, actual );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testEscapedVariablePassthroughInLargerExpression()
    throws Exception
{
    String var = "${var}";
    String key = var + " with version: ${project.version}";

    Model model = new Model();
    model.setVersion( "1" );

    MavenProject project = new MavenProject( model );

    ExpressionEvaluator ee = createExpressionEvaluator( project, null, new Properties() );

    Object value = ee.evaluate( "$" + key );

    assertEquals( "${var} with version: 1", value );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testMultipleSubExpressionsInLargerExpression()
    throws Exception
{
    String key = "${project.artifactId} with version: ${project.version}";

    Model model = new Model();
    model.setArtifactId( "test" );
    model.setVersion( "1" );

    MavenProject project = new MavenProject( model );

    ExpressionEvaluator ee = createExpressionEvaluator( project, null, new Properties() );

    Object value = ee.evaluate( key );

    assertEquals( "test with version: 1", value );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testPOMPropertyExtractionWithMissingProject_WithDotNotation()
    throws Exception
{
    String key = "m2.name";
    String checkValue = "value";

    Properties properties = new Properties();
    properties.setProperty( key, checkValue );

    Model model = new Model();
    model.setProperties( properties );

    MavenProject project = new MavenProject( model );

    ExpressionEvaluator ee = createExpressionEvaluator( project, null, new Properties() );

    Object value = ee.evaluate( "${" + key + "}" );

    assertEquals( checkValue, value );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testValueExtractionFromSystemPropertiesWithMissingProject()
    throws Exception
{
    String sysprop = "PPEET_sysprop1";

    Properties executionProperties = new Properties();

    if ( executionProperties.getProperty( sysprop ) == null )
    {
        executionProperties.setProperty( sysprop, "value" );
    }

    ExpressionEvaluator ee = createExpressionEvaluator( null, null, executionProperties );

    Object value = ee.evaluate( "${" + sysprop + "}" );

    assertEquals( "value", value );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testValueExtractionFromSystemPropertiesWithMissingProject_WithDotNotation()
    throws Exception
{
    String sysprop = "PPEET.sysprop2";

    Properties executionProperties = new Properties();

    if ( executionProperties.getProperty( sysprop ) == null )
    {
        executionProperties.setProperty( sysprop, "value" );
    }

    ExpressionEvaluator ee = createExpressionEvaluator( null, null, executionProperties );

    Object value = ee.evaluate( "${" + sysprop + "}" );

    assertEquals( "value", value );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
public void testTwoExpressions()
    throws Exception
{
    Build build = new Build();
    build.setDirectory( "expected-directory" );
    build.setFinalName( "expected-finalName" );

    Model model = new Model();
    model.setBuild( build );

    ExpressionEvaluator expressionEvaluator =
        createExpressionEvaluator( new MavenProject( model ), null, new Properties() );

    Object value = expressionEvaluator.evaluate( "${project.build.directory}" + FS + "${project.build.finalName}" );

    assertEquals( "expected-directory" + File.separatorChar + "expected-finalName", value );
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private void handlePropertyEditorFields(Object mojo,
		List<PropertyEditorField> editorSupportFields,
		ExpressionEvaluator expressionEvaluator) {
	for (PropertyEditorField propertyEditorField : editorSupportFields) {
		PropertyEditorComponent<?> propertyEditorComponent = propertyEditorLookup
				.getPropertyEditorComponent(propertyEditorField);
		String propertyName = propertyEditorField.getProperty();
		Object propValue;
		try {
			propValue = expressionEvaluator.evaluate("${" + propertyName
					+ "}");
			if (propValue == null) {
				continue;
			}
			String propertyValueString = null;
			propertyValueString = propValue.toString();
			propertyEditorField.setValue(propertyEditorComponent,
					propertyValueString);
		} catch (ExpressionEvaluationException e) {
			throw new IllegalStateException("Unable to inject "
					+ propertyEditorField + " with property named "
					+ propertyName, e);
		}
	}
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm)
		throws ComponentConfigurationException {
	List<String> runtimeClasspathElements;
	try {
		// noinspection unchecked
		runtimeClasspathElements = (List<String>) expressionEvaluator
				.evaluate("${project.runtimeClasspathElements}");
	} catch (ExpressionEvaluationException e) {
		throw new ComponentConfigurationException(
				"There was a problem evaluating: ${project.runtimeClasspathElements}", e);
	}

	// Add the project dependencies to the ClassRealm
	final URL[] urls = buildURLs(runtimeClasspathElements);
	for (URL url : urls) {
		containerRealm.addConstituent(url);
	}
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private void addProjectDependenciesToClassRealm(
        final ExpressionEvaluator expressionEvaluator,
        final ClassRealm containerRealm)
        throws ComponentConfigurationException {

    List<String> testClasspathElements;

    try {
        // noinspection unchecked

        testClasspathElements = (List<String>) expressionEvaluator
                .evaluate("${project.testClasspathElements}");

    } catch (final ExpressionEvaluationException e) {
        throw new ComponentConfigurationException(
                "There was a problem evaluating: ${project.runtimeClasspathElements}",
                e);
    }

    if (testClasspathElements != null) {
        // Add the project test dependencies to the ClassRealm
        final URL[] testUrls = buildURLs(testClasspathElements);

        this.log.info("Adding the following jars to the Substeps classpath, tests will be executed with this classpath\n");

        for (final String s : testClasspathElements) {
            this.log.info("\t" + s);
        }
        this.log.info("\n\n");

        for (final URL url : testUrls) {

            containerRealm.addURL(url);
        }
    }

}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入方法依赖的package包/类
private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm) throws ComponentConfigurationException {
    List<String> runtimeClasspathElements;
    try {
        //noinspection unchecked
        runtimeClasspathElements = (List<String>) expressionEvaluator.evaluate("${project.runtimeClasspathElements}");
    } catch (ExpressionEvaluationException e) {
        throw new ComponentConfigurationException("There was a problem evaluating: ${project.runtimeClasspathElements}", e);
    }

    final URL[] urls = buildURLs(runtimeClasspathElements);
    for (URL url : urls) {
        containerRealm.addConstituent(url);
    }
}