Package org.apache.maven.artifact.resolver

Examples of org.apache.maven.artifact.resolver.ArtifactResolver


            remoteRepositories.add( factory.createArtifactRepository( "apache.snapshots",
                                                                      "http://people.apache.org/repo/m2-snapshot-repository",
                                                                      layout, null, null ) );
        }

        ArtifactResolver resolver = (ArtifactResolver) container.lookup( ArtifactResolver.ROLE );

        List<String> exclusions = new ArrayList<String>();
        exclusions.add( "org.apache.continuum:data-management-api" );
        exclusions.add( "org.codehaus.plexus:plexus-component-api" );
        exclusions.add( "org.codehaus.plexus:plexus-container-default" );
        exclusions.add( "org.slf4j:slf4j-api" );
        exclusions.add( "log4j:log4j" );

        ArtifactFilter filter = new ExcludesArtifactFilter( exclusions );

        List<? extends ResolutionListener> listeners;
        if ( LOGGER.isDebugEnabled() )
        {
            listeners = Collections.singletonList( new DebugResolutionListener( container.getLogger() ) );
        }
        else
        {
            listeners = Collections.emptyList();
        }

        ArtifactMetadataSource source = (ArtifactMetadataSource) container.lookup( ArtifactMetadataSource.ROLE,
                                                                                   "maven" );
        ArtifactResolutionResult result = resolver.resolveTransitively( Collections.singleton( artifact ),
                                                                        dummyArtifact, Collections.emptyMap(),
                                                                        localRepository, remoteRepositories, source,
                                                                        filter, listeners );

        return result.getArtifacts();
View Full Code Here


        ArtifactResolutionResult result;
        try
        {
            MavenMetadataSource metadataSource = (MavenMetadataSource) lookup( ArtifactMetadataSource.ROLE );
            ArtifactResolver resolver = (ArtifactResolver) lookup( ArtifactResolver.ROLE );
            List<ArtifactRepository> remoteRepositories = createRemoteArtifactRepositories();

            result = resolver.resolveTransitively( Collections.singleton( providerArtifact ),
                                                   createDummyArtifact(), createLocalArtifactRepository(),
                                                   remoteRepositories, metadataSource, null );
        }
        catch ( ArtifactResolutionException e )
        {
View Full Code Here

    {
        ArtifactRepository localRepo = createLocalArtifactRepository();
        log( "Using local repository: " + localRepo.getBasedir(), Project.MSG_VERBOSE );

        // Look up required resources from the plexus container
        ArtifactResolver resolver = (ArtifactResolver) lookup( ArtifactResolver.ROLE );
        ArtifactFactory artifactFactory = (ArtifactFactory) lookup( ArtifactFactory.ROLE );
        MavenMetadataSource metadataSource = (MavenMetadataSource) lookup( ArtifactMetadataSource.ROLE );

        Pom pom = initializePom( localRepo );
        if ( pom != null )
        {
            dependencies = pom.getDependencies();
        }
        else
        {
            // we have to have some sort of Pom object in order to satisfy the requirements for building the
            // originating Artifact below...
            pom = createDummyPom( localRepo );
        }

        if ( dependencies.isEmpty() )
        {
            log( "There were no dependencies specified", Project.MSG_WARN );
        }
        else
        {
            // check scopes
            for ( Dependency dependency : dependencies )
            {
                String scope = dependency.getScope();

                if ( Artifact.SCOPE_SYSTEM.equals( scope ) )
                {
                    if ( StringUtils.isBlank( dependency.getSystemPath() ) )
                    {
                        throw new BuildException( dependency.toString()
                            + " is defined with scope='system': systemPath attribute is required." );
                    }
                }
                else if ( ( scope != null ) && !SCOPES_SET.contains( scope ) )
                {
                    // see MANTTASKS-190
                    log( "Unknown scope='" + scope + "' for " + dependency + ", supported scopes are: " + SCOPES_SET,
                         Project.MSG_WARN );
                }
            }
        }

        log( "Resolving dependencies...", Project.MSG_VERBOSE );

        ArtifactResolutionResult result;

        List<ArtifactRepository> remoteArtifactRepositories = createRemoteArtifactRepositories( pom.getRepositories() );

        try
        {
            Set<Artifact> artifacts = MavenMetadataSource.createArtifacts( artifactFactory, dependencies, null, null, null );

            Artifact pomArtifact = artifactFactory.createBuildArtifact( pom.getGroupId(), pom.getArtifactId(),
                pom.getVersion(), pom.getPackaging() );

            List<AntResolutionListener> listeners = Collections.singletonList( new AntResolutionListener( getProject() ) );

            Map<String,Artifact> managedDependencies = pom.getMavenProject().getManagedVersionMap();

            ArtifactFilter filter = null;
            if ( useScope != null )
            {
                filter = new ScopeArtifactFilter( useScope );
            }
            if ( scopes != null )
            {
                filter = new SpecificScopesArtifactFilter( scopes );
            }
            if ( type != null )
            {
                ArtifactFilter typeArtifactFilter = new TypesArtifactFilter( type );
                if ( filter != null )
                {
                    AndArtifactFilter andFilter = new AndArtifactFilter();
                    andFilter.add( filter );
                    andFilter.add( typeArtifactFilter );
                    filter = andFilter;
                }
                else
                {
                    filter = typeArtifactFilter;
                }
            }

            result = resolver.resolveTransitively( artifacts, pomArtifact, managedDependencies, localRepo,
                                                   remoteArtifactRepositories, metadataSource, filter, listeners );
        }
        catch ( ArtifactResolutionException e )
        {
            throw new BuildException( "Unable to resolve artifact: " + e.getMessage(), e );
View Full Code Here

    }

    ArtifactFactory factory = request.getArtifactFactory();
    Artifact artifact = factory.createArtifact(NATIVE_GROUPID,
                          NATIVE_ARTIFACTID, version, "", NATIVE_TYPE);
    ArtifactResolver resolver = request.getArtifactResolver();

    try
    {
      resolver.resolve(artifact, request.getRemoteRepositories(),
        request.getLocalRepository());

      File nativeArchive = artifact.getFile();
      UnArchiver unArchiver =
        request.getArchiverManager().getUnArchiver(nativeArchive);
View Full Code Here

    tests.addInclude("**/*test.html");

    MavenProject project = createMock(MavenProject.class);
    Artifact artifact = createMock(Artifact.class);
    ArtifactFactory artifactFactory = createMock(ArtifactFactory.class);
    ArtifactResolver artifactResolver = createMock(ArtifactResolver.class);
    ArtifactRepository repository = createMock(ArtifactRepository.class);
    ArtifactMetadataSource metadataSource = createMock(
        ArtifactMetadataSource.class);
    ArtifactResolutionResult results = createMock(
        ArtifactResolutionResult.class);
    Build build = createMock(Build.class);

    expect(project.getBasedir())
        .andReturn(new File(baseDirectory)).once();
    expect(project.getBuild()).andReturn(build).once();
    expect(project.getTestClasspathElements())
      .andReturn(new LinkedList<String>()).anyTimes();
    expect(project.getDependencies()).andReturn(new LinkedList<Dependency>())
      .once();
    expect(project.getArtifact()).andReturn(artifact).once();
    expect(artifactResolver.resolveTransitively(
        new HashSet<Artifact>(), artifact,
        Collections.EMPTY_LIST, repository, metadataSource))
        .andReturn(results).anyTimes();
    expect(results.getArtifacts()).andReturn(new HashSet<Artifact>());

View Full Code Here

        ArtifactResolutionResult result;
        try
        {
            MavenMetadataSource metadataSource = (MavenMetadataSource) lookup( ArtifactMetadataSource.ROLE );
            ArtifactResolver resolver = (ArtifactResolver) lookup( ArtifactResolver.ROLE );
            List remoteRepositories = createRemoteArtifactRepositories();

            result = resolver.resolveTransitively( Collections.singleton( providerArtifact ),
                                                   createArtifact( createDummyPom() ), createLocalArtifactRepository(),
                                                   remoteRepositories, metadataSource, null );
        }
        catch ( ArtifactResolutionException e )
        {
View Full Code Here

        showVersion();
       
        ArtifactRepository localRepo = createLocalArtifactRepository();
        log( "Using local repository: " + localRepo.getBasedir(), Project.MSG_VERBOSE );

        ArtifactResolver resolver = (ArtifactResolver) lookup( ArtifactResolver.ROLE );
        MavenProjectBuilder projectBuilder = (MavenProjectBuilder) lookup( MavenProjectBuilder.ROLE );
        ArtifactFactory artifactFactory = (ArtifactFactory) lookup( ArtifactFactory.ROLE );
        MavenMetadataSource metadataSource = (MavenMetadataSource) lookup( ArtifactMetadataSource.ROLE );

        List dependencies = this.dependencies;

        Pom pom = buildPom( projectBuilder, localRepo );
        if ( pom != null )
        {
            if ( !dependencies.isEmpty() )
            {
                throw new BuildException( "You cannot specify both dependencies and a pom in the dependencies task" );
            }

            dependencies = pom.getDependencies();

            for ( Iterator i = pom.getRepositories().iterator(); i.hasNext(); )
            {
                Repository pomRepository = (Repository) i.next();

                addRemoteRepository( createAntRemoteRepository( pomRepository ) );
            }
        }
        else
        {
            // we have to have some sort of Pom object in order to satisfy the requirements for building the
            // originating Artifact below...
            pom = createDummyPom();
        }

        if ( dependencies.isEmpty() )
        {
            log( "There were no dependencies specified", Project.MSG_WARN );
        }

        log( "Resolving dependencies...", Project.MSG_VERBOSE );

        WagonManager wagonManager = (WagonManager) lookup( WagonManager.ROLE );
        wagonManager.setDownloadMonitor( new AntDownloadMonitor() );

        ArtifactResolutionResult result;
        Set artifacts;

        List remoteArtifactRepositories = createRemoteArtifactRepositories();

        try
        {
            artifacts = MavenMetadataSource.createArtifacts( artifactFactory, dependencies, null, null, null );

            Artifact pomArtifact = artifactFactory.createBuildArtifact( pom.getGroupId(), pom.getArtifactId(), pom
                .getVersion(), pom.getPackaging() );

            List listeners = Collections.singletonList( new AntResolutionListener( getProject(), verbose ) );

            // TODO: managed dependencies
            Map managedDependencies = Collections.EMPTY_MAP;

            ArtifactFilter filter = null;
            if ( useScope != null )
            {
                filter = new ScopeArtifactFilter( useScope );
            }
            if ( type != null )
            {
                TypeArtifactFilter typeArtifactFilter = new TypeArtifactFilter( type );
                if ( filter != null )
                {
                    AndArtifactFilter andFilter = new AndArtifactFilter();
                    andFilter.add( filter );
                    andFilter.add( typeArtifactFilter );
                    filter = andFilter;
                }
                else
                {
                    filter = typeArtifactFilter;
                }
            }

            result = resolver.resolveTransitively( artifacts, pomArtifact, managedDependencies, localRepo,
                                                   remoteArtifactRepositories, metadataSource, filter, listeners );
        }
        catch ( ArtifactResolutionException e )
        {
            throw new BuildException( "Unable to resolve artifact: " + e.getMessage(), e );
        }
        catch ( ArtifactNotFoundException e )
        {
            throw new BuildException( "Dependency not found: " + e.getMessage(), e );
        }
        catch ( InvalidDependencyVersionException e )
        {
            throw new BuildException( e.getMessage(), e );
        }

        /*
        MANTTASKS-37: Do what other ant tasks do and just override the path id.
        if ( pathId != null && getProject().getReference( pathId ) != null )
        {
            throw new BuildException( "Reference ID " + pathId + " already exists" );
        }

        if ( filesetId != null && getProject().getReference( filesetId ) != null )
        {
            throw new BuildException( "Reference ID " + filesetId + " already exists" );
        }

        if ( sourcesFilesetId != null && getProject().getReference( sourcesFilesetId ) != null )
        {
            throw new BuildException( "Reference ID " + sourcesFilesetId + " already exists" );
        }
        */

        FileList fileList = new FileList();
        fileList.setDir( getLocalRepository().getPath() );

        FileSet fileSet = new FileSet();
        fileSet.setProject( getProject() );
        fileSet.setDir( fileList.getDir( getProject() ) );

        FileList sourcesFileList = new FileList();
        sourcesFileList.setDir( getLocalRepository().getPath() );

        FileSet sourcesFileSet = new FileSet();
        sourcesFileSet.setDir( sourcesFileList.getDir( getProject() ) );

        Set versions = new HashSet();
       
        if ( result.getArtifacts().isEmpty() )
        {
            fileSet.createExclude().setName( "**/**" );
        }
        else
        {
            for ( Iterator i = result.getArtifacts().iterator(); i.hasNext(); )
            {
                Artifact artifact = (Artifact) i.next();
                artifact.isSnapshot(); // MNG-2961: DefaultArtifact getBaseVersion is changed to "xxxx-SNAPSHOT" only if you first call isSnapshot()
                String filename = localRepo.pathOf( artifact );

                FileList.FileName file = new FileList.FileName();
                file.setName( filename );

                fileList.addConfiguredFile( file );

                fileSet.createInclude().setName( filename );
               
                versions.add( artifact.getBaseVersion() );

                if ( sourcesFilesetId != null )
                {
                    log( "Resolving dependencies sources...", Project.MSG_VERBOSE );
                    // get sources
                    Artifact sourcesArtifact =
                        artifactFactory.createArtifactWithClassifier( artifact.getGroupId(), artifact.getArtifactId(),
                                                                      artifact.getVersion(), "java-source", "sources" );
                    if ( sourcesArtifact != null )
                    {
                        try
                        {
                            resolver.resolve( sourcesArtifact, remoteArtifactRepositories, localRepo );
                            String sourcesFilename = localRepo.pathOf( sourcesArtifact );

                            FileList.FileName sourcesFile = new FileList.FileName();
                            sourcesFile.setName( sourcesFilename );

View Full Code Here

            Artifact parentArtifact = factory.createParentArtifact( groupId, artifactId, version );

            try
            {
                MavenMetadataSource metadataSource = (MavenMetadataSource) lookup( ArtifactMetadataSource.ROLE );
                ArtifactResolver resolver = (ArtifactResolver) lookup( ArtifactResolver.ROLE );
                List remoteRepositories = createRemoteArtifactRepositories();

                resolver.resolveTransitively( Collections.singleton( parentArtifact ),
                                              createArtifact( createDummyPom() ), createLocalArtifactRepository(),
                                              remoteRepositories, metadataSource, null );
            }
            catch ( ArtifactResolutionException e )
            {
View Full Code Here

        }

        ArtifactFactory factory = request.getArtifactFactory();
        Artifact artifact = factory.createArtifact( JSW_GROUPID, JSW_ARTIFACTID, version, "",  JSW_TYPE);

        ArtifactResolver resolver = request.getArtifactResolver();
        try
        {
            resolver.resolve( artifact, request.getRemoteRepositories(), request.getLocalRepository() );

            File wrapperArchive = artifact.getFile();
            UnArchiver unArchiver = request.getArchiverManager().getUnArchiver( wrapperArchive );
            unArchiver.setSourceFile( wrapperArchive );
            unArchiver.setDestDirectory( outputDirectory );
View Full Code Here

        Field artifactFactoryField = ShadeMojo.class.getDeclaredField( "artifactFactory" );
        artifactFactoryField.setAccessible( true );
        artifactFactoryField.set( mojo, artifactFactory );

        // configure artifactResolver (mocked) for mojo
        ArtifactResolver mockArtifactResolver = new DefaultArtifactResolver()
        {

            public void resolve( Artifact artifact, List<ArtifactRepository> remoteRepos, ArtifactRepository repo )
                throws ArtifactResolutionException, ArtifactNotFoundException
            {
                // artifact is resolved
                artifact.setResolved( true );

                // set file
                artifact.setFile( new File(
                    artifact.getArtifactId() + "-" + artifact.getVersion() + ( artifact.getClassifier() != null ? "-"
                        + artifact.getClassifier() : "" ) + ".jar" ) );
            }

        };
        Field artifactResolverField = ShadeMojo.class.getDeclaredField( "artifactResolver" );
        artifactResolverField.setAccessible( true );
        artifactResolverField.set( mojo, mockArtifactResolver );

        // create and configure MavenProject
        MavenProject project = new MavenProject();
        ArtifactHandler artifactHandler = (ArtifactHandler) lookup( ArtifactHandler.ROLE );
        Artifact artifact = new DefaultArtifact( "org.apache.myfaces.core", "myfaces-impl",
                                                 VersionRange.createFromVersion( "2.0.1-SNAPSHOT" ), "compile", "jar",
                                                 null, artifactHandler );
        mockArtifactResolver.resolve( artifact, null, null ); // setFile and setResolved
        project.setArtifact( artifact );
        Field projectField = ShadeMojo.class.getDeclaredField( "project" );
        projectField.setAccessible( true );
        projectField.set( mojo, project );
View Full Code Here

TOP

Related Classes of org.apache.maven.artifact.resolver.ArtifactResolver

Copyright © 2018 www.massapicom. All rights reserved.
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.