Java InvalidVersionSpecificationException.getMessage方法代码示例

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
/**
 *
 * @param projectId
 * @param dependencyManagement
 * @return
 * @throws ProjectBuildingException
 */
private Map createManagedVersionMap(String projectId, DependencyManagement dependencyManagement) throws ProjectBuildingException {
    Map map;
    if (dependencyManagement != null && dependencyManagement.getDependencies() != null) {
        map = new HashMap();
        for (Dependency d : dependencyManagement.getDependencies()) {
            try {
                VersionRange versionRange = VersionRange.createFromVersionSpec(d.getVersion());
                Artifact artifact = factory.createDependencyArtifact(d.getGroupId(), d.getArtifactId(),
                        versionRange, d.getType(), d.getClassifier(),
                        d.getScope());
                map.put(d.getManagementKey(), artifact);
            } catch (InvalidVersionSpecificationException e) {
                throw new ProjectBuildingException(projectId, "Unable to parse version '" + d.getVersion()
                        + "' for dependency '" + d.getManagementKey() + "': " + e.getMessage(), e);
            }
        }
    } else {
        map = Collections.EMPTY_MAP;
    }
    return map;
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
/**
 * Try to find the dependency artifact that matches the given dependency.
 *
 * @param dependency
 * @return
 * @since 1.0-alpha-3
 */
protected Artifact toArtifact( Dependency dependency )
    throws MojoExecutionException
{
    Artifact artifact = findArtifact( dependency );
    if ( artifact == null )
    {
        try
        {
            return getHelper().createDependencyArtifact( dependency );
        }
        catch ( InvalidVersionSpecificationException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }
    }
    return artifact;
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
private Artifact createDependencyArtifact( Dependency dependency, Artifact owner, Artifact pom )
    throws ArtifactMetadataRetrievalException
{
    try
    {
        String inheritedScope = ( owner != null ) ? owner.getScope() : null;

        ArtifactFilter inheritedFilter = ( owner != null ) ? owner.getDependencyFilter() : null;

        return createDependencyArtifact( repositorySystem, dependency, inheritedScope, inheritedFilter );
    }
    catch ( InvalidVersionSpecificationException e )
    {
        throw new ArtifactMetadataRetrievalException( "Invalid version for dependency "
            + dependency.getManagementKey() + ": " + e.getMessage(), e, pom );
    }
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
protected Map createManagedVersionMap(String projectId,
        DependencyManagement dependencyManagement) throws ProjectBuildingException {
    Map map;
    if (dependencyManagement != null
            && dependencyManagement.getDependencies() != null) {
        map = new HashMap();
        for (Iterator i = dependencyManagement.getDependencies().iterator(); i
                .hasNext();) {
            Dependency d = (Dependency) i.next();

            try {
                VersionRange versionRange = VersionRange
                        .createFromVersionSpec(d.getVersion());
                Artifact artifact = factory.createDependencyArtifact(d
                        .getGroupId(), d.getArtifactId(), versionRange, d
                        .getType(), d.getClassifier(), d.getScope());
                map.put(d.getManagementKey(), artifact);
            } catch (InvalidVersionSpecificationException e) {
                throw new ProjectBuildingException(projectId,
                        "Unable to parse version '" + d.getVersion()
                                + "' for dependency '"
                                + d.getManagementKey() + "': "
                                + e.getMessage(), e);
            }
        }
    } else {
        map = Collections.EMPTY_MAP;
    }
    return map;
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
public boolean isActive( Profile profile )
    throws ProfileActivationException
{
    Activation activation = profile.getActivation();

    String jdk = activation.getJdk();

    // null case is covered by canDetermineActivation(), so we can do a straight startsWith() here.
    if ( jdk.startsWith( "[" ) || jdk.startsWith( "(" ) )
    {
        try
        {
            return matchJdkVersionRange( jdk );
        }
        catch ( InvalidVersionSpecificationException e )
        {
            throw new ProfileActivationException( "Invalid JDK version in profile '" + profile.getId() + "': "
                + e.getMessage() );
        }
    }

    boolean reverse = false;

    if ( jdk.startsWith( "!" ) )
    {
        reverse = true;
        jdk = jdk.substring( 1 );
    }

    if ( getJdkVersion().startsWith( jdk ) )
    {
        return !reverse;
    }
    else
    {
        return reverse;
    }
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
private Artifact getComparisonArtifact()
    throws MojoFailureException, MojoExecutionException
{
    // Find the previous version JAR and resolve it, and it's dependencies
    VersionRange range;
    try
    {
        range = VersionRange.createFromVersionSpec( comparisonVersion );
    }
    catch ( InvalidVersionSpecificationException e )
    {
        throw new MojoFailureException( "Invalid comparison version: " + e.getMessage() );
    }

    Artifact previousArtifact;
    try
    {
        previousArtifact = factory.createDependencyArtifact( project.getGroupId(), project.getArtifactId(), range,
                                                             project.getPackaging(), null, Artifact.SCOPE_COMPILE );

        if ( !previousArtifact.getVersionRange().isSelectedVersionKnown( previousArtifact ) )
        {
            getLog().debug( "Searching for versions in range: " + previousArtifact.getVersionRange() );
            List availableVersions = metadataSource.retrieveAvailableVersions( previousArtifact, localRepository,
                                                                               project.getRemoteArtifactRepositories() );
            filterSnapshots( availableVersions );
            ArtifactVersion version = range.matchVersion( availableVersions );
            if ( version != null )
            {
                previousArtifact.selectVersion( version.toString() );
            }
        }
    }
    catch ( OverConstrainedVersionException e1 )
    {
        throw new MojoFailureException( "Invalid comparison version: " + e1.getMessage() );
    }
    catch ( ArtifactMetadataRetrievalException e11 )
    {
        throw new MojoExecutionException( "Error determining previous version: " + e11.getMessage(), e11 );
    }

    if ( previousArtifact.getVersion() == null )
    {
        getLog().info( "Unable to find a previous version of the project in the repository" );
    }

    return previousArtifact;
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
public ArtifactHolder(Log log, ArtifactDependencyResolver resolver, List<MavenProject> reactorProjects) throws MojoExecutionException {
    // collect
    reactorArtifacts = new HashSet<Artifact>();
    for (MavenProject reactorProject : reactorProjects)
        reactorArtifacts.add(reactorProject.getArtifact());
    reactorArtifacts = Collections.unmodifiableSet(reactorArtifacts);

    // Resolve
    Map<MavenProject, ArtifactDependencyResolver.DependencyData> dependencyDataNewMap;
    try {
        dependencyDataNewMap = resolver.findDependencies(reactorProjects);
    } catch (InvalidVersionSpecificationException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // Find common dependencies
    Set<Artifact> fullSet = new HashSet<Artifact>();
    for (ArtifactDependencyResolver.DependencyData data : dependencyDataNewMap.values())
        fullSet.addAll(data.getRemoteList());

    // Save allDependencies
    allDependencies = new ArrayList<Artifact>(fullSet);
    Collections.sort(allDependencies, ArtifactComparator.INSTANCE);
    allDependencies = Collections.unmodifiableList(allDependencies);

    log.info("");
    log.info("Full Dependencies");
    log.info("");
    for (Artifact artifact : allDependencies)
        log.info("  " + artifact.getId());

    // Save dependencyMap

    this.dependencyMap = new HashMap<MavenProject, List<Artifact>>();
    for (Map.Entry<MavenProject, ArtifactDependencyResolver.DependencyData> entry : dependencyDataNewMap.entrySet()) {
        MavenProject project = entry.getKey();
        // Remove commonSet from dependencies
        List<Artifact> remoteList = new ArrayList<Artifact>(entry.getValue().getRemoteList());
        List<Artifact> reactorList = new ArrayList<Artifact>(entry.getValue().getReactorList());
        Collections.sort(remoteList, ArtifactComparator.INSTANCE);
        Collections.sort(reactorList, ArtifactComparator.INSTANCE);
        List<Artifact> artifacts = new ArrayList<Artifact>();
        artifacts.addAll(reactorList);
        artifacts.addAll(remoteList);
        this.dependencyMap.put(project, Collections.unmodifiableList(artifacts));
    }
}
 

import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; //导入方法依赖的package包/类
private static String formatMessage( String projectId, String locationInPom, String offendingVersion,
                                     InvalidVersionSpecificationException cause )
{
    return "Invalid version: " + offendingVersion + " found for: " + locationInPom + " in project: " + projectId
        + ". Reason: " + cause.getMessage();
}