Java ExpressionEvaluator类代码示例

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入依赖的package包/类
static @NonNull ConfigurationBuilder<String> simpleProperty(final @NonNull String property) {
    return new ConfigurationBuilder<String>() {

        @Override
        public String build(Xpp3Dom configRoot, ExpressionEvaluator eval) {
            if (configRoot != null) {
                Xpp3Dom source = configRoot.getChild(property);
                if (source != null) {
                    String value = source.getValue();
                    if (value == null) {
                        return null;
                    }
                    return value.trim();
                }
            }
            return null;
        }
    };
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入依赖的package包/类
static @NonNull ConfigurationBuilder<String[]> listProperty(final @NonNull String multiProperty, final @NonNull String singleProperty) {
    return new ConfigurationBuilder<String[]>() {
        @Override
        public String[] build(Xpp3Dom conf, ExpressionEvaluator eval) {
            if (conf != null) {
                Xpp3Dom dom = (Xpp3Dom) conf; // MNG-4862
                Xpp3Dom source = dom.getChild(multiProperty);
                if (source != null) {
                    List<String> toRet = new ArrayList<String>();
                    Xpp3Dom[] childs = source.getChildren(singleProperty);
                    for (Xpp3Dom ch : childs) {
                        String chvalue = ch.getValue() == null ? "" : ch.getValue().trim();  //NOI18N
                        toRet.add(chvalue);  //NOI18N
                    }
                    return toRet.toArray(new String[toRet.size()]);
                }
            }
            return null;
        }
    };
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入依赖的package包/类
/**
 * Evaluator usable for interpolating variables in non resolved (interpolated) models. 
 * Should not be necessary when dealing with the project's <code>MavenProject</code> instance accessed via<code>NbMavenProject.getMavenProject()</code>
 * @since 2.57
 */
public static @NonNull ExpressionEvaluator createEvaluator(@NonNull Project project) {
    NbMavenProjectImpl prj = project instanceof NbMavenProjectImpl ? (NbMavenProjectImpl)project : project.getLookup().lookup(NbMavenProjectImpl.class);
    assert prj != null;
    MavenProject mvnprj = prj.getOriginalMavenProject();
    //the idea here is to tie the lifecycle of the evaluator to the lifecycle of the MavenProject, both
    //get changed when settings.xml is changed or pom is change or when a profile gets updated..
    ExpressionEvaluator eval = (ExpressionEvaluator) mvnprj.getContextValue(CONTEXT_EXPRESSION_EVALUATOR);
    if (eval == null) {
        Settings ss = EmbedderFactory.getProjectEmbedder().getSettings();
        ss.setLocalRepository(EmbedderFactory.getProjectEmbedder().getLocalRepository().getBasedir());

        eval =  new NBPluginParameterExpressionEvaluator(
            mvnprj,
            ss,
            prj.createSystemPropsForPropertyExpressions(),
            prj.createUserPropsForPropertyExpressions());
        mvnprj.setContextValue(CONTEXT_EXPRESSION_EVALUATOR, eval);
    }
    return eval;
}
 

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator; //导入依赖的package包/类
@Override
public void configureComponent(final Object component,
                               final PlexusConfiguration configuration,
                               final ExpressionEvaluator expressionEvaluator,
                               final ClassRealm containerRealm,
                               final ConfigurationListener listener)
        throws ComponentConfigurationException {

    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

    this.converterLookup.registerConverter(new ClassRealmConverter(containerRealm));

    final ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();

    converter.processConfiguration(this.converterLookup, component,
            containerRealm, configuration,
            expressionEvaluator, listener);

}
 

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包/类
@SuppressWarnings("unchecked")
private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm)
    throws ComponentConfigurationException
{
  Set<String> runtimeClasspathElements = new HashSet<String>();
  try
  {
    runtimeClasspathElements.addAll((List<String>) expressionEvaluator
        .evaluate("${project.runtimeClasspathElements}"));
    
  }
  catch (ExpressionEvaluationException e)
  {
    throw new ComponentConfigurationException("There was a problem evaluating: ${project.runtimeClasspathElements}",
        e);
  }
  
  Collection<URL> urls = buildURLs(runtimeClasspathElements);
  urls.addAll(buildAritfactDependencies(expressionEvaluator));
  for (URL url : urls)
  {
    // containerRealm.addConstituent(url);
    containerRealm.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包/类
@SuppressWarnings("unchecked")
private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm) throws ComponentConfigurationException {
    Set<String> runtimeClasspathElements = new HashSet<String>();
    try {
        runtimeClasspathElements.addAll((List<String>) expressionEvaluator.evaluate("${project.runtimeClasspathElements}"));

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

    Collection<URL> urls = this.buildURLs(runtimeClasspathElements);
    urls.addAll(this.buildAritfactDependencies(expressionEvaluator));
    for (URL url : urls) {
        containerRealm.addConstituent(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 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 JdkToolchain fromConfiguration( PlexusConfiguration configuration, ExpressionEvaluator expressionEvaluator )
    throws ComponentConfigurationException
{
    PlexusConfiguration[] params = configuration.getChildren();
    Map parameters = new HashMap();
    for ( int j = 0; j < params.length; j++ )
    {
        try
        {
            String name = params[j].getName();
            String val = params[j].getValue();
            parameters.put( name, val );
        }
        catch ( PlexusConfigurationException ex )
        {
            throw new ComponentConfigurationException( ex );
        }
    }
    final JdkToolchain result = new JdkToolchain();
    result.setParameters( Collections.unmodifiableMap( parameters ) );
    return result;
}
 

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 );
}