Examples of org.codehaus.plexus.configuration.PlexusConfiguration

Package org.codehaus.plexus.configuration

Examples of org.codehaus.plexus.configuration.PlexusConfiguration

org.codehaus.plexus.configuration.PlexusConfiguration


        PlexusConfiguration[] components = c.getChild( "components" ).getChildren( "component" );


        for ( int i = 0; i < components.length; i++ )
        {
            PlexusConfiguration component = components[i];


            csd.addComponentDescriptor( buildComponentDescriptorImpl( component, realm ) );
        }


        // ----------------------------------------------------------------------
        // Dependencies
        // ----------------------------------------------------------------------


        PlexusConfiguration[] dependencies = c.getChild( "dependencies" ).getChildren( "dependency" );


        for ( int i = 0; i < dependencies.length; i++ )
        {
            PlexusConfiguration d = dependencies[i];


            ComponentDependency cd = new ComponentDependency();


            cd.setArtifactId( d.getChild( "artifact-id" ).getValue() );


            cd.setGroupId( d.getChild( "group-id" ).getValue() );


            String type = d.getChild( "type" ).getValue();
            if(type != null)
            {
                cd.setType( type );
            }


            cd.setVersion( d.getChild( "version" ).getValue() );


            csd.addDependency( cd );
        }


        return csd;

View Full Code Here

                ( (Mojo) mojo ).setLog( new DefaultLog( logger ) );
            }


            Xpp3Dom dom = mojoExecution.getConfiguration();


            PlexusConfiguration pomConfiguration;


            if ( dom == null )
            {
                pomConfiguration = new XmlPlexusConfiguration( "configuration" );
            }

View Full Code Here

                continue;
            }


            Object value = null;


            PlexusConfiguration config = configuration.getChild( parameter.getName(), false );
            if ( config != null )
            {
                String expression = config.getValue( null );


                try
                {
                    value = expressionEvaluator.evaluate( expression );


                    if ( value == null )
                    {
                        value = config.getAttribute( "default-value", null );
                    }
                }
                catch ( ExpressionEvaluationException e )
                {
                    String msg =
                        "Error evaluating the expression '" + expression + "' for configuration value '"
                            + configuration.getName() + "'";
                    throw new ComponentConfigurationException( configuration, msg, e );
                }
            }


            if ( value == null && ( config == null || config.getChildCount() <= 0 ) )
            {
                invalidParameters.add( parameter );
            }
        }

View Full Code Here


            log.debug( "configureWagon server " + id );


            if ( id != null && id.equals( repositoryId ) && ( server.getConfiguration() != null ) )
            {
                final PlexusConfiguration plexusConf =
                    new XmlPlexusConfiguration( (Xpp3Dom) server.getConfiguration() );


                ComponentConfigurator componentConfigurator = null;
                try
                {

View Full Code Here

                ( (Mojo) mojo ).setLog( new DefaultLog( logger ) );
            }


            Xpp3Dom dom = mojoExecution.getConfiguration();


            PlexusConfiguration pomConfiguration;


            if ( dom == null )
            {
                pomConfiguration = new XmlPlexusConfiguration( "configuration" );
            }

View Full Code Here

                continue;
            }


            Object value = null;


            PlexusConfiguration config = configuration.getChild( parameter.getName(), false );
            if ( config != null )
            {
                String expression = config.getValue( null );


                try
                {
                    value = expressionEvaluator.evaluate( expression );


                    if ( value == null )
                    {
                        value = config.getAttribute( "default-value", null );
                    }
                }
                catch ( ExpressionEvaluationException e )
                {
                    String msg =
                        "Error evaluating the expression '" + expression + "' for configuration value '"
                            + configuration.getName() + "'";
                    throw new ComponentConfigurationException( configuration, msg, e );
                }
            }


            if ( value == null && ( config == null || config.getChildCount() <= 0 ) )
            {
                invalidParameters.add( parameter );
            }
        }

View Full Code Here

    {
        StringBuffer message = new StringBuffer();


        PluginDescriptor descriptor = getPluginDescriptor();


        PlexusConfiguration failedConfiguration = cce.getFailedConfiguration();


        message.append( "Failed to configure plugin parameters for: " + descriptor.getId() + "\n\n" );


        if ( failedConfiguration != null )
        {
            String value = failedConfiguration.getValue( null );
            if ( value != null )
            {
                addParameterUsageInfo( value, message );
            }
        }

View Full Code Here

    }


    public PluginDescriptor build( Reader reader, String source )
        throws PlexusConfigurationException
    {
        PlexusConfiguration c = buildConfiguration( reader );


        PluginDescriptor pluginDescriptor = new PluginDescriptor();


        pluginDescriptor.setSource( source );
        pluginDescriptor.setGroupId( c.getChild( "groupId" ).getValue() );
        pluginDescriptor.setArtifactId( c.getChild( "artifactId" ).getValue() );
        pluginDescriptor.setVersion( c.getChild( "version" ).getValue() );
        pluginDescriptor.setGoalPrefix( c.getChild( "goalPrefix" ).getValue() );
        
        pluginDescriptor.setName( c.getChild( "name" ).getValue() );
        pluginDescriptor.setDescription( c.getChild( "description" ).getValue() );


        String isolatedRealm = c.getChild( "isolatedRealm" ).getValue();


        if ( isolatedRealm != null )
        {
            pluginDescriptor.setIsolatedRealm( Boolean.valueOf( isolatedRealm ).booleanValue() );
        }


        String inheritedByDefault = c.getChild( "inheritedByDefault" ).getValue();


        if ( inheritedByDefault != null )
        {
            pluginDescriptor.setInheritedByDefault( Boolean.valueOf( inheritedByDefault ).booleanValue() );
        }


        // ----------------------------------------------------------------------
        // Components
        // ----------------------------------------------------------------------


        PlexusConfiguration[] mojoConfigurations = c.getChild( "mojos" ).getChildren( "mojo" );


        for ( int i = 0; i < mojoConfigurations.length; i++ )
        {
            PlexusConfiguration component = mojoConfigurations[i];


            MojoDescriptor mojoDescriptor = buildComponentDescriptor( component, pluginDescriptor );


            pluginDescriptor.addMojo( mojoDescriptor );
        }


        // ----------------------------------------------------------------------
        // Dependencies
        // ----------------------------------------------------------------------


        PlexusConfiguration[] dependencyConfigurations = c.getChild( "dependencies" ).getChildren( "dependency" );


        List dependencies = new ArrayList();


        for ( int i = 0; i < dependencyConfigurations.length; i++ )
        {
            PlexusConfiguration d = dependencyConfigurations[i];


            ComponentDependency cd = new ComponentDependency();


            cd.setArtifactId( d.getChild( "artifactId" ).getValue() );


            cd.setGroupId( d.getChild( "groupId" ).getValue() );


            cd.setType( d.getChild( "type" ).getValue() );


            cd.setVersion( d.getChild( "version" ).getValue() );


            dependencies.add( cd );
        }


        pluginDescriptor.setDependencies( dependencies );

View Full Code Here


        mojo.setGoal( c.getChild( "goal" ).getValue() );
        
        mojo.setImplementation( c.getChild( "implementation" ).getValue() );


        PlexusConfiguration langConfig = c.getChild( "language" );


        if ( langConfig != null )
        {
            mojo.setLanguage( langConfig.getValue() );
        }


        PlexusConfiguration configuratorConfig = c.getChild( "configurator" );


        if ( configuratorConfig != null )
        {
            mojo.setComponentConfigurator( configuratorConfig.getValue() );
        }


        PlexusConfiguration composerConfig = c.getChild( "composer" );


        if ( composerConfig != null )
        {
            mojo.setComponentComposer( composerConfig.getValue() );
        }


        String since = c.getChild( "since" ).getValue();


        if ( since != null )
        {
            mojo.setSince( since );
        }


        String phase = c.getChild( "phase" ).getValue();


        if ( phase != null )
        {
            mojo.setPhase( phase );
        }


        String executePhase = c.getChild( "executePhase" ).getValue();


        if ( executePhase != null )
        {
            mojo.setExecutePhase( executePhase );
        }


        String executeMojo = c.getChild( "executeGoal" ).getValue();


        if ( executeMojo != null )
        {
            mojo.setExecuteGoal( executeMojo );
        }


        String executeLifecycle = c.getChild( "executeLifecycle" ).getValue();


        if ( executeLifecycle != null )
        {
            mojo.setExecuteLifecycle( executeLifecycle );
        }


        mojo.setInstantiationStrategy( c.getChild( "instantiationStrategy" ).getValue() );


        mojo.setDescription( c.getChild( "description" ).getValue() );


        String dependencyResolution = c.getChild( "requiresDependencyResolution" ).getValue();


        if ( dependencyResolution != null )
        {
            mojo.setDependencyResolutionRequired( dependencyResolution );
        }


        String directInvocationOnly = c.getChild( "requiresDirectInvocation" ).getValue();


        if ( directInvocationOnly != null )
        {
            mojo.setDirectInvocationOnly( Boolean.valueOf( directInvocationOnly ).booleanValue() );
        }


        String requiresProject = c.getChild( "requiresProject" ).getValue();


        if ( requiresProject != null )
        {
            mojo.setProjectRequired( Boolean.valueOf( requiresProject ).booleanValue() );
        }


        String requiresReports = c.getChild( "requiresReports" ).getValue();


        if ( requiresReports != null )
        {
            mojo.setRequiresReports( Boolean.valueOf( requiresReports ).booleanValue() );
        }


        String aggregator = c.getChild( "aggregator" ).getValue();


        if ( aggregator != null )
        {
            mojo.setAggregator( Boolean.valueOf( aggregator ).booleanValue() );
        }


        String requiresOnline = c.getChild( "requiresOnline" ).getValue();


        if ( requiresOnline != null )
        {
            mojo.setOnlineRequired( Boolean.valueOf( requiresOnline ).booleanValue() );
        }


        String inheritedByDefault = c.getChild( "inheritedByDefault" ).getValue();


        if ( inheritedByDefault != null )
        {
            mojo.setInheritedByDefault( Boolean.valueOf( inheritedByDefault ).booleanValue() );
        }


        // ----------------------------------------------------------------------
        // Parameters
        // ----------------------------------------------------------------------


        PlexusConfiguration[] parameterConfigurations = c.getChild( "parameters" ).getChildren( "parameter" );


        List parameters = new ArrayList();


        for ( int i = 0; i < parameterConfigurations.length; i++ )
        {
            PlexusConfiguration d = parameterConfigurations[i];


            Parameter parameter = new Parameter();


            parameter.setName( d.getChild( "name" ).getValue() );


            parameter.setAlias( d.getChild( "alias" ).getValue() );


            parameter.setType( d.getChild( "type" ).getValue() );


            String required = d.getChild( "required" ).getValue();


            parameter.setRequired( Boolean.valueOf( required ).booleanValue() );


            PlexusConfiguration editableConfig = d.getChild( "editable" );


            // we need the null check for pre-build legacy plugins...
            if ( editableConfig != null )
            {
                String editable = d.getChild( "editable" ).getValue();


                parameter.setEditable( editable == null || Boolean.valueOf( editable ).booleanValue() );
            }


            parameter.setDescription( d.getChild( "description" ).getValue() );


            parameter.setDeprecated( d.getChild( "deprecated" ).getValue() );


            parameter.setImplementation( d.getChild( "implementation" ).getValue() );


            parameters.add( parameter );
        }


        mojo.setParameters( parameters );


        // TODO: this should not need to be handed off...


        // ----------------------------------------------------------------------
        // Configuration
        // ----------------------------------------------------------------------


        mojo.setMojoConfiguration( c.getChild( "configuration" ) );


        // TODO: Go back to this when we get the container ready to configure mojos...
        //        mojo.setConfiguration( c.getChild( "configuration" ) );


        // ----------------------------------------------------------------------
        // Requirements
        // ----------------------------------------------------------------------


        PlexusConfiguration[] requirements = c.getChild( "requirements" ).getChildren( "requirement" );


        for ( int i = 0; i < requirements.length; i++ )
        {
            PlexusConfiguration requirement = requirements[i];


            ComponentRequirement cr = new ComponentRequirement();


            cr.setRole( requirement.getChild( "role" ).getValue() );


            cr.setRoleHint( requirement.getChild( "role-hint" ).getValue() );


            cr.setFieldName( requirement.getChild( "field-name" ).getValue() );


            mojo.addRequirement( cr );
        }


        return mojo;

View Full Code Here


        // Validate against non-editable (@readonly) parameters, to make sure users aren't trying to
        // override in the POM.
        validatePomConfiguration( mojoDescriptor, pomConfiguration );


        PlexusConfiguration mergedConfiguration = mergeMojoConfiguration( pomConfiguration, mojoDescriptor );


        // TODO: plexus changes to make this more like the component descriptor so this can be used instead
        //            PlexusConfiguration mergedConfiguration = mergeConfiguration( pomConfiguration,
        //                                                                          mojoDescriptor.getConfiguration() );


        ExpressionEvaluator expressionEvaluator = new PluginParameterExpressionEvaluator( session, mojoExecution,
                                                                                          pathTranslator,
                                                                                          getLogger(),
                                                                                          project,
                                                                                          session.getExecutionProperties() );


        PlexusConfiguration extractedMojoConfiguration =
            extractMojoConfiguration( mergedConfiguration, mojoDescriptor );


        checkRequiredParameters( mojoDescriptor, extractedMojoConfiguration, expressionEvaluator );


        populatePluginFields( plugin, mojoDescriptor, extractedMojoConfiguration, pluginContainer,

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.codehaus.plexus.configuration.PlexusConfiguration

ch.inftec.ju.maven.test.DebugPropertiesMojoTest

ch.inftec.ju.maven.test.GreetMojoJUnit3Test

ch.inftec.ju.maven.test.GreetMojoJUnit4Test

com.google.code.configprocessor.maven.AntrunXmlPlexusConfigurationWriter

hudson.maven.MojoInfo

hudson.maven.reporters.BuildInfoRecorder

hudson.plugins.cobertura.MavenCoberturaPublisher

org.apache.felix.bundleplugin.JarPluginConfiguration

org.apache.maven.artifact.manager.DefaultWagonManager

org.apache.maven.configuration.internal.DefaultBeanConfigurator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.