List of usage examples for org.apache.maven.artifact.versioning VersionRange restrict
public VersionRange restrict(VersionRange restriction)
VersionRange that is a restriction of this version range and the specified version range. From source file:ch.ivyteam.ivy.maven.AbstractEngineMojo.java
License:Apache License
protected final VersionRange getIvyVersionRange() throws MojoExecutionException { try {// w w w . ja v a 2s .co m VersionRange minimalCompatibleVersionRange = VersionRange .createFromVersionSpec("[" + AbstractEngineMojo.MINIMAL_COMPATIBLE_VERSION + ",)"); VersionRange ivyVersionRange = VersionRange.createFromVersionSpec(ivyVersion); if (ivyVersionRange.getRecommendedVersion() != null) { ivyVersionRange = VersionRange.createFromVersionSpec("[" + ivyVersion + "]"); } VersionRange restrictedIvyVersionRange = ivyVersionRange.restrict(minimalCompatibleVersionRange); if (!restrictedIvyVersionRange.hasRestrictions()) { throw new MojoExecutionException( "The ivyVersion '" + ivyVersion + "' is lower than the minimal compatible version" + " '" + MINIMAL_COMPATIBLE_VERSION + "'."); } return restrictedIvyVersionRange; } catch (InvalidVersionSpecificationException ex) { throw new MojoExecutionException("Invalid ivyVersion '" + ivyVersion + "'.", ex); } }
From source file:com.adviser.maven.GraphArtifactCollector.java
License:Apache License
private ResolutionNode checkPreviousNodes(ResolutionNode node, List listeners, List previousNodes) throws OverConstrainedVersionException { for (Iterator i = previousNodes.iterator(); i.hasNext();) { ResolutionNode previous = (ResolutionNode) i.next(); if (previous.isActive()) { // Version mediation VersionRange previousRange = previous.getArtifact().getVersionRange(); VersionRange currentRange = node.getArtifact().getVersionRange(); // TODO: why do we force the version on it? what if they // don't match? if (previousRange == null) { // version was already resolved node.getArtifact().setVersion(previous.getArtifact().getVersion()); } else if (currentRange == null) { // version was already resolved previous.getArtifact().setVersion(node.getArtifact().getVersion()); } else { // TODO: shouldn't need to double up on this work, only // done for simplicity of handling recommended // version but the restriction is identical VersionRange newRange = previousRange.restrict(currentRange); // TODO: ick. this forces the OCE that should have come // from the previous call. It is still correct if (newRange.isSelectedVersionKnown(previous.getArtifact())) { fireEvent(ResolutionListener.RESTRICT_RANGE, listeners, node, previous.getArtifact(), newRange);//w ww. j a v a2 s.c o m } previous.getArtifact().setVersionRange(newRange); node.getArtifact().setVersionRange(currentRange.restrict(previousRange)); // Select an appropriate available version from the (now // restricted) range // Note this version was selected before to get the // appropriate POM // But it was reset by the call to setVersionRange on // restricting the version ResolutionNode[] resetNodes = { previous, node }; for (int j = 0; j < 2; j++) { Artifact resetArtifact = resetNodes[j].getArtifact(); if (resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null && resetArtifact.getAvailableVersions() != null) { resetArtifact.selectVersion(resetArtifact.getVersionRange() .matchVersion(resetArtifact.getAvailableVersions()).toString()); fireEvent(ResolutionListener.SELECT_VERSION_FROM_RANGE, listeners, resetNodes[j]); } } } // Conflict Resolution // TODO: use as conflict resolver(s), chain // TODO: should this be part of mediation? // previous one is more dominant if (previous.getDepth() <= node.getDepth()) { checkScopeUpdate(node, previous, listeners); } else { checkScopeUpdate(previous, node, listeners); } if (previous.getDepth() <= node.getDepth()) { // previous was nearer fireEvent(ResolutionListener.OMIT_FOR_NEARER, listeners, node, previous.getArtifact()); node.disable(); node = previous; } else { fireEvent(ResolutionListener.OMIT_FOR_NEARER, listeners, previous, node.getArtifact()); previous.disable(); } } } return node; }
From source file:org.codehaus.mojo.versions.api.PomHelper.java
License:Apache License
/** * Checks if two versions or ranges have an overlap. * * @param leftVersionOrRange the 1st version number or range to test * @param rightVersionOrRange the 2nd version number or range to test * @return true if both versions have an overlap * @throws InvalidVersionSpecificationException * if the versions can't be parsed to a range *//* w ww . jav a 2 s . com*/ public static boolean isVersionOverlap(String leftVersionOrRange, String rightVersionOrRange) throws InvalidVersionSpecificationException { VersionRange pomVersionRange = createVersionRange(leftVersionOrRange); if (!pomVersionRange.hasRestrictions()) { return true; } VersionRange oldVersionRange = createVersionRange(rightVersionOrRange); if (!oldVersionRange.hasRestrictions()) { return true; } VersionRange result = oldVersionRange.restrict(pomVersionRange); return result.hasRestrictions(); }
From source file:org.universAAL.maven.treebuilder.DependencyTreeBuilder.java
License:Apache License
/** * The heart of the tree builder. Recursively resolves provided artifact. * Output is passed to listeners, passed as argument, which are notified * about all dependencies detected in the tree. Resolving of each child node * is delegated to resolveChildNode method. * // w w w . ja v a 2s . com * @param originatingArtifact * Rootnode of recursed subtree. * @param node * Current node which is resolved. * @param resolvedArtifacts * Map which is used for remembering already resolved artifacts. * Artifacts are indexed by a key which calculation algorithm is * the same as the one present in calculateDepKey method. Thanks * to this map, duplicates and conflicts are detected and * resolved. * @param managedVersions * Information about dependency management extracted from the * subtree rootnode - a maven project. * @param localRepository * Local maven repository. * @param remoteRepositories * Remote repositories provided by maven. * @param source * ArtifactMetadataSource provided by maven. * @param filter * Filter used for unfiltering artifacts which should not be * included in the dependency tree. * @param listener * Listener used for providing the output of the resolve process. * @param transitive * If this parameter is false than the children of current node * are not resolved. * * @throws CyclicDependencyException * Exception thrown when cyclic dependency detected. * @throws ArtifactResolutionException * Exception thrown when a problem with artifact resolution * occurs. * @throws OverConstrainedVersionException * Occurs when ranges exclude each other and no valid value * remains. * @throws ArtifactMetadataRetrievalException * Error while retrieving repository metadata from the * repository. * @throws NoSuchFieldException * Signals that the class doesn't have a field of a specified * name. * @throws SecurityException * Thrown by the security manager to indicate a security * violation. * @throws IllegalAccessException * When illegal access is performed in the curse of java * reflection operations. * @throws IllegalArgumentException * Thrown to indicate that an illegal or inappropriate argument * has been passed. */ private void recurse(final Artifact originatingArtifact, final ResolutionNode node, final Map resolvedArtifacts, final ManagedVersionMap managedVersions, final ArtifactRepository localRepository, final List remoteRepositories, final ArtifactMetadataSource source, final ArtifactFilter filter, final DependencyTreeResolutionListener listener, final boolean transitive, final Set<String> separatedGroupIds) throws CyclicDependencyException, ArtifactResolutionException, OverConstrainedVersionException, ArtifactMetadataRetrievalException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException { try { fireEvent(ResolutionListener.TEST_ARTIFACT, listener, node); Object key = node.getKey(); // TODO: Does this check need to happen here? Had to add the same // call // below when we iterate on child nodes -- will that suffice? if (managedVersions.containsKey(key)) { manageArtifact(node, managedVersions); } List previousNodes = (List) resolvedArtifacts.get(key); if (previousNodes != null) { for (Iterator i = previousNodes.iterator(); i.hasNext();) { ResolutionNode previous = (ResolutionNode) i.next(); if (previous.isActive()) { // Version mediation VersionRange previousRange = previous.getArtifact().getVersionRange(); VersionRange currentRange = node.getArtifact().getVersionRange(); if (previousRange != null && currentRange != null) { // TODO: shouldn't need to double up on this work, // only // done for simplicity of handling recommended // version but the restriction is identical VersionRange newRange = previousRange.restrict(currentRange); // TODO: ick. this forces the OCE that should have // come // from the previous call. It is still correct if (newRange.isSelectedVersionKnown(previous.getArtifact())) { fireEvent(ResolutionListener.RESTRICT_RANGE, listener, node, previous, newRange); } previous.getArtifact().setVersionRange(newRange); node.getArtifact().setVersionRange(currentRange.restrict(previousRange)); // Select an appropriate available version from the // (now // restricted) range // Note this version was selected before to get the // appropriate POM // But it was reset by the call to setVersionRange // on // restricting the version ResolutionNode[] resetNodes = { previous, node }; for (int j = 0; j < 2; j++) { Artifact resetArtifact = resetNodes[j].getArtifact(); // MNG-2123: if the previous node was not a // range, // then it wouldn't have any available // versions. We just clobbered the selected // version // above. (why? i have no idea.) // So since we are here and this is ranges we // must // go figure out the version (for a third // time...) if (resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null) { // go find the version. This is a total // hack. // See previous comment. List versions = resetArtifact.getAvailableVersions(); if (versions == null) { try { versions = source.retrieveAvailableVersions(resetArtifact, localRepository, remoteRepositories); resetArtifact.setAvailableVersions(versions); } catch (ArtifactMetadataRetrievalException e) { resetArtifact.setDependencyTrail(node.getDependencyTrail()); throw e; } } // end hack // MNG-2861: match version can return null ArtifactVersion selectedVersion = resetArtifact.getVersionRange() .matchVersion(resetArtifact.getAvailableVersions()); if (selectedVersion != null) { resetArtifact.selectVersion(selectedVersion.toString()); } else { throw new OverConstrainedVersionException( " Unable to find a version in " + resetArtifact.getAvailableVersions() + " to match the range " + resetArtifact.getVersionRange(), resetArtifact); } fireEvent(ResolutionListener.SELECT_VERSION_FROM_RANGE, listener, resetNodes[j]); } } } // Conflict Resolution // TODO: use as conflict resolver(s), chain // TODO: should this be part of mediation? // previous one is more dominant ResolutionNode nearest; ResolutionNode farthest; if (previous.getDepth() <= node.getDepth()) { nearest = previous; farthest = node; } else { nearest = node; farthest = previous; } if (checkScopeUpdate(farthest, nearest)) { // if we need to update scope of nearest to use // farthest // scope, use the nearest version, but farthest // scope nearest.disable(); farthest.getArtifact().setVersion(nearest.getArtifact().getVersion()); fireEvent(ResolutionListener.OMIT_FOR_NEARER, listener, nearest, farthest); } else { farthest.disable(); fireEvent(ResolutionListener.OMIT_FOR_NEARER, listener, farthest, nearest); } } } } else { previousNodes = new ArrayList(); resolvedArtifacts.put(key, previousNodes); } previousNodes.add(node); if (node.isActive()) { fireEvent(ResolutionListener.INCLUDE_ARTIFACT, listener, node); } // don't pull in the transitive deps of a system-scoped dependency. if (node.isActive() && !Artifact.SCOPE_SYSTEM.equals(node.getArtifact().getScope())) { fireEvent(ResolutionListener.PROCESS_CHILDREN, listener, node); if (transitive) { Artifact parentArtifact = node.getArtifact(); for (Iterator i = node.getChildrenIterator(); i.hasNext();) { ResolutionNode child = (ResolutionNode) i.next(); if (!filter.include(child.getArtifact())) { continue; } /* * rotgier: In case of regular dependencies provided * scope is simply ignored (artifact versions specified * there conflict with the ones of runtime deps) */ if (Artifact.SCOPE_PROVIDED.equals(child.getArtifact().getScope())) { continue; } changeArtifactCoreToOsgi(node, child, separatedGroupIds, listener); boolean isContinue = resolveChildNode(node, child, filter, managedVersions, listener, source, parentArtifact); if (isContinue) { continue; } List<String> extractedSeparatedGroupIds = extractSeparatedGroupIds(child.getArtifact(), remoteRepositories); Set<String> combinedSeparatedGroupIds = new HashSet<String>(separatedGroupIds); combinedSeparatedGroupIds.addAll(extractedSeparatedGroupIds); recurse(originatingArtifact, child, resolvedArtifacts, managedVersions, localRepository, child.getRemoteRepositories(), source, filter, listener, true, combinedSeparatedGroupIds); } List runtimeDeps = getRuntimeDeps(node.getArtifact(), managedVersions, remoteRepositories); Field childrenField = node.getClass().getDeclaredField("children"); childrenField.setAccessible(true); List nodesChildren = (List) childrenField.get(node); /* nodesChildren can be empty when dealing with parent POMs */ if (nodesChildren == Collections.EMPTY_LIST) { nodesChildren = new ArrayList(); childrenField.set(node, nodesChildren); } for (Object runtimeDepObj : runtimeDeps) { DependencyNode runtimeDep = (DependencyNode) runtimeDepObj; Artifact artifact = runtimeDep.getArtifact(); ResolutionNode childRuntime = new ResolutionNode(artifact, node.getRemoteRepositories(), node); /* * rotgier: In case of runtime dependencies provided * scope should be allowed */ if (!filter.include(childRuntime.getArtifact())) { if (!Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) { continue; } } changeArtifactCoreToOsgi(node, childRuntime, separatedGroupIds, listener); boolean isContinue = resolveChildNode(node, childRuntime, filter, managedVersions, listener, source, parentArtifact); if (isContinue) { continue; } List<String> extractedSeparatedGroupIds = extractSeparatedGroupIds( childRuntime.getArtifact(), remoteRepositories); Set<String> combinedSeparatedGroupIds = new HashSet<String>(separatedGroupIds); combinedSeparatedGroupIds.addAll(extractedSeparatedGroupIds); recurse(originatingArtifact, childRuntime, resolvedArtifacts, managedVersions, localRepository, childRuntime.getRemoteRepositories(), source, filter, listener, true, combinedSeparatedGroupIds); nodesChildren.add(childRuntime); } } fireEvent(ResolutionListener.FINISH_PROCESSING_CHILDREN, listener, node); } } catch (Exception ex) { StringBuilder msg = new StringBuilder(); msg.append(String.format("\nUnpredicted exception during dependency tree recursion at node %s", FilteringVisitorSupport.stringify(node.getArtifact()))); msg.append("\nNode's parent tree:\n"); msg.append(printNodeParentsTree(node)); throw new IllegalStateException(msg.toString(), ex); } }