/** * Gets the artifact for the specified node. * * @param node the dependency node, possibly <code>null</code> * @return the node's artifact, or <code>null</code> if the specified node was <code>null</code> */ private static Artifact nullGetArtifact( DependencyNode node ) { return ( node != null ) ? node.getArtifact() : null; } }
/** * {@inheritDoc} */ public boolean endVisit( DependencyNode node ) { parentNodes.pop(); // apply the visitor to the resultant tree on the last visit if ( parentNodes.empty() && visitor != null ) { rootNode.accept( visitor ); } return true; }
/** * {@inheritDoc} */ public int hashCode() { // TODO: probably better using commons-lang HashCodeBuilder int hashCode = 1; hashCode = hashCode * HASH_PRIME + getArtifact().hashCode(); // DefaultArtifact.hashCode does not consider scope hashCode = hashCode * HASH_PRIME + nullHashCode( getArtifact().getScope() ); // TODO: use parent's artifact to prevent recursion - how can we improve this? hashCode = hashCode * HASH_PRIME + nullHashCode( nullGetArtifact( getParent() ) ); hashCode = hashCode * HASH_PRIME + getChildren().hashCode(); hashCode = hashCode * HASH_PRIME + getState(); hashCode = hashCode * HASH_PRIME + nullHashCode( getRelatedArtifact() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getPremanagedVersion() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getPremanagedScope() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getOriginalScope() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getFailedUpdateScope() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getVersionSelectedFromRange() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getAvailableVersions() ); return hashCode; }
/** * Gets whether the first dependency node is an ancestor-or-self of the second. * * @param ancestorNode the ancestor-or-self dependency node * @param descendantNode the dependency node to test * @return <code>true</code> if <code>ancestorNode</code> is an ancestor, or equal to, <code>descendantNode</code> */ private boolean isAncestorOrSelf( DependencyNode ancestorNode, DependencyNode descendantNode ) { boolean ancestor = false; while ( !ancestor && descendantNode != null ) { ancestor = ancestorNode.equals( descendantNode ); descendantNode = descendantNode.getParent(); } return ancestor; } }
/** * {@inheritDoc} */ public boolean visit( DependencyNode node ) { // clone the node DependencyNode newNode = new DependencyNode( node.getArtifact(), node.getState(), node.getRelatedArtifact() ); newNode.setOriginalScope( node.getOriginalScope() ); newNode.setFailedUpdateScope( node.getFailedUpdateScope() ); newNode.setPremanagedVersion( node.getPremanagedVersion() ); newNode.setPremanagedScope( node.getPremanagedScope() ); if ( parentNodes.empty() ) { rootNode = newNode; } else { DependencyNode parentNode = parentNodes.peek(); parentNode.addChild( newNode ); } parentNodes.push( newNode ); return true; }
@Override public boolean visit(DependencyNode node) { if (root == null) { root = node; lst = new ArrayList<DependencyNode>(); } for (DependencyNode ch : node.getChildren()) { if (ch.getState() == DependencyNode.INCLUDED && scopes.contains(ch.getArtifact().getScope())) { lst.add(ch); } } return true; }
protected static DependencyNode getNode(DependencyNode rootNode, String requiredKey, boolean verbose) { for (Iterator<?> itr = rootNode.preorderIterator(); itr.hasNext();) { DependencyNode d = (DependencyNode) itr.next(); Artifact artifact = d.getArtifact(); String key = getArtifactId(artifact); if (log.isDebugEnabled()) { log.debug("key : " + key); } if (requiredKey.equals(key) && d.getState() == DependencyNode.INCLUDED) { return d; } } return null; }
if ( node.getVersionSelectedFromRange() != null ) versionSelectedFromRange = node.getVersionSelectedFromRange().toString(); new DefaultDependencyNode( parent, node.getArtifact(), node.getPremanagedVersion(), node.getPremanagedScope(), versionSelectedFromRange ); List<DependencyNode> nodes = new ArrayList<DependencyNode>( node.getChildren().size() ); for ( org.apache.maven.shared.dependency.tree.DependencyNode child : node.getChildren() ) if ( child.getState() != org.apache.maven.shared.dependency.tree.DependencyNode.INCLUDED ) if ( ( filter == null ) || filter.include( child.getArtifact() ) )
protected void saveDependency(final Project project, DependencyNode node, SensorContext context) { Resource from = (node.getParent().getParent() == null) ? index.getProject() : toResource(project, node.getParent().getArtifact(), context); Resource to = toResource(project, node.getArtifact(), context); Dependency dependency = new Dependency(from, to); dependency.setUsage(node.getArtifact().getScope()); dependency.setWeight(1); context.saveDependency(dependency); }
helper.getLog().debug("[victims-enforcer] artifact id of root = " + treeRoot.getArtifact().toString()); treeRoot.accept(visitor); if (node.getState() == DependencyNode.INCLUDED && ! treeRoot.equals(node)){ Artifact artifact = node.getArtifact(); if (artifact != null){ artifacts.add(artifact);
private String traverseNode(DependencyNode node) { Artifact artifact = node.getArtifact(); if ((protobufGroupId.equals(artifact.getGroupId()) && (protobufArtifactId.equals(artifact.getArtifactId())))){ return artifact.getVersion(); } for (Object o: node.getChildren()){ DependencyNode child = (DependencyNode)o; String result = traverseNode(child); if (result!=null) return result; } return null; } }
rootNode.accept(visitor); List<ITypeLoader> deps = new ArrayList<>(); for (DependencyNode dependencyNode : nodes) { int state = dependencyNode.getState(); Artifact artifact = dependencyNode.getArtifact(); addDependency(artifact, deps);
visitor.setUniqueVersions( true ); node.accept( visitor ); String key = dependencyNode.getArtifact().getGroupId() + ":" + dependencyNode.getArtifact().getArtifactId(); dependencyList.add( new ReverseDependencyLink( toDependency( dependencyNode.getArtifact() ), reactorProject ) ); dependencyList.add( new ReverseDependencyLink( toDependency( workNode.getArtifact() ), reactorProject ) );
private String getFullArtifactName( DependencyNode node, boolean usePremanaged ) { Artifact artifact = node.getArtifact(); String version = node.getPremanagedVersion(); if ( !usePremanaged || version == null ) { version = uniqueVersions ? artifact.getVersion() : artifact.getBaseVersion(); } return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + version; }
if ( !dependencyTree.hasChildren() ) for ( Iterator it = dependencyTree.inverseIterator(); it.hasNext(); ) if ( node.getState() != DependencyNode.INCLUDED ) if ( Artifact.SCOPE_SYSTEM.equals( node.getArtifact().getScope() ) ) getLog().debug( "Ignoring system scoped artifact " + node.getArtifact() ); continue; try artifact = resolveArtifact( node.getArtifact() ); throw new MojoExecutionException( "Artifact was not found in the repo" + node.getArtifact(), e ); node.getArtifact().setFile( artifact.getFile() ); int nodeDepth = node.getDepth(); if ( nodeDepth > maxDepth ) "Ignoring " + node.getArtifact() + ", depth is " + nodeDepth + ", bigger than " + maxDepth ); continue;
if ( getState() != INCLUDED ) if ( !relatedArtifact.getDependencyConflictId().equals( getArtifact().getDependencyConflictId() ) ) if ( getArtifact().getVersion() != null ) duplicate = getArtifact().getVersion().equals( relatedArtifact.getVersion() ); else if ( getArtifact().getVersionRange() != null ) duplicate = getArtifact().getVersionRange().equals( relatedArtifact.getVersionRange() ); throw new RuntimeException( "Artifact version and version range is null: " + getArtifact() ); removeAllChildren();
/** * Updates the specified node with any dependency management information cached in prior <code>manageArtifact</code> * calls. * * @param node * the node to update */ private void flushDependencyManagement( DependencyNode node ) { Artifact artifact = node.getArtifact(); String premanagedVersion = ( String ) managedVersions.get( getRangeId( artifact ) ); String premanagedScope = ( String ) managedScopes.get( getRangeId( artifact ) ); if ( premanagedVersion != null || premanagedScope != null ) { if ( premanagedVersion != null ) { node.setPremanagedVersion( premanagedVersion ); } if ( premanagedScope != null ) { node.setPremanagedScope( premanagedScope ); } premanagedVersion = null; premanagedScope = null; } }
public TreeNode(DependencyNode node, final Lookup tcLookup) { super(createTreeChildren(node, tcLookup), Lookups.fixed(node)); this.tcLookup = tcLookup; final Artifact artifact = node.getArtifact(); setName(artifact.getId()); this.node = node; setDisplayName(artifact.getArtifactId() + "-" + artifact.getVersion() + "." + artifact.getArtifactHandler().getExtension()); if (node.getDepth() > 1) { setIconBaseWithExtension(IconResources.TRANSITIVE_DEPENDENCY_ICON); } else { setIconBaseWithExtension(IconResources.ICON_DEPENDENCY_JAR); } setShortDescription(Bundle.TIP_listNode(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), calculateStateTipPart(node))); }
/** * Applies the specified dependency node visitor to this dependency node and its children. * * @param visitor the dependency node visitor to use * @return the visitor result of ending the visit to this node * @since 1.1 */ public boolean accept( DependencyNodeVisitor visitor ) { if ( visitor.visit( this ) ) { for ( DependencyNode child : getChildren() ) { if ( !child.accept( visitor ) ) { break; } } } return visitor.endVisit( this ); }
private Set<Node> recurse(Artifact a, Node rootContext, BeanTreeView btv) { Set<Node> toRet = new HashSet<Node>(); for (Node nd : rootContext.getChildren().getNodes(true)) { DependencyNode n = nd.getLookup().lookup(DependencyNode.class); if (n != null) { if (n.getArtifact().equals(a) || (n.getRelatedArtifact() != null && n.getRelatedArtifact().equals(a))) { btv.expandNode(rootContext); toRet.add(nd); } } toRet.addAll(recurse(a, nd, btv)); } return toRet; }