/** * Writes the necessary tokens to indent the specified dependency node to this visitor's writer. * * @param node the dependency node to indent */ private void indent( DependencyNode node ) { for ( int i = 1; i < depth; i++ ) { writer.write( tokens.getFillIndent( isLast( node, i ) ) ); } if ( depth > 0 ) { writer.write( tokens.getNodeIndent( isLast( node ) ) ); } }
/** * {@inheritDoc} */ public boolean visit( DependencyNode node ) { indent( node ); writer.println( node.toNodeString() ); depth++; return true; }
/** * {@inheritDoc} */ public boolean endVisit( DependencyNode node ) { boolean visit; if ( filter.accept( node ) ) { visit = visitor.endVisit( node ); } else { visit = true; } return visit; }
/** * Serializes the specified dependency tree to a string. * * @param rootNode the dependency tree root node to serialize * @return the serialized dependency tree */ private void serializeDependencyTree( DependencyNode rootNode, String key, Sink sink ) { DependencyNodeVisitor visitor = getSerializingDependencyNodeVisitor( sink ); visitor = new BuildingDependencyNodeVisitor( visitor ); DependencyNodeFilter nodeFilter = createDependencyNodeFilter( key ); if ( nodeFilter != null ) { CollectingDependencyNodeVisitor collectingVisitor = new CollectingDependencyNodeVisitor(); DependencyNodeVisitor firstPassVisitor = new FilteringDependencyNodeVisitor( collectingVisitor, nodeFilter ); rootNode.accept( firstPassVisitor ); DependencyNodeFilter secondPassFilter = new AncestorOrSelfDependencyNodeFilter( collectingVisitor.getNodes() ); visitor = new FilteringDependencyNodeVisitor( visitor, secondPassFilter ); } rootNode.accept( visitor ); }
/** * {@inheritDoc} * * @deprecated */ public DependencyTree buildDependencyTree( MavenProject project, ArtifactRepository repository, ArtifactFactory factory, ArtifactMetadataSource metadataSource, ArtifactCollector collector ) throws DependencyTreeBuilderException { DependencyNode rootNode = buildDependencyTree( project, repository, factory, metadataSource, null, collector ); CollectingDependencyNodeVisitor collectingVisitor = new CollectingDependencyNodeVisitor(); rootNode.accept( collectingVisitor ); return new DependencyTree( rootNode, collectingVisitor.getNodes() ); }
/** Visits a node (and all dependencies) to see if it contains duplicate scala versions */ private void checkArtifactForScalaVersion(String requiredScalaVersion, DependencyNode rootNode) throws Exception { final CheckScalaVersionVisitor visitor = new CheckScalaVersionVisitor(requiredScalaVersion, getLog()); CollectingDependencyNodeVisitor collectingVisitor = new CollectingDependencyNodeVisitor(); DependencyNodeVisitor firstPassVisitor = new FilteringDependencyNodeVisitor( collectingVisitor, createScalaDistroDependencyFilter() ); rootNode.accept( firstPassVisitor ); DependencyNodeFilter secondPassFilter = new AncestorOrSelfDependencyNodeFilter( collectingVisitor.getNodes() ); DependencyNodeVisitor filteredVisitor = new FilteringDependencyNodeVisitor( visitor, secondPassFilter ); rootNode.accept( filteredVisitor ); if(visitor.isFailed()) { visitor.logScalaDependents(); if(failOnMultipleScalaVersions) { getLog().error("Multiple versions of scala libraries detected!"); throw new MojoFailureException("Multiple versions of scala libraries detected!"); } getLog().warn("Multiple versions of scala libraries detected!"); } }
/** * 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 ); }
/** * {@inheritDoc} */ public boolean visit( DependencyNode node ) { boolean visit; if ( filter.accept( node ) ) { visit = visitor.visit( node ); } else { visit = true; } return visit; }
/** * Returns a string representation of this dependency node and its children. * * @return the string representation * @see #toNodeString() * @see java.lang.Object#toString() */ public String toString() { StringWriter writer = new StringWriter(); accept( new SerializingDependencyNodeVisitor( writer ) ); return writer.toString(); }
/** * Gets whether the specified dependency node ancestor is the last of its siblings. * * @param node the dependency node whose ancestor to check * @param ancestorDepth the depth of the ancestor of the specified dependency node to check * @return <code>true</code> if the specified dependency node ancestor is the last of its siblings */ private boolean isLast( DependencyNode node, int ancestorDepth ) { // TODO: remove node argument and calculate from visitor calls only int distance = depth - ancestorDepth; while ( distance-- > 0 ) { node = node.getParent(); } return isLast( node ); } }
private void computeDependencyTree(final Project project, final SensorContext context) { LOG.warn("Computation of Maven dependencies by SonarQube is deprecated. Please update the version of SonarQube Maven plugin to 2.5+"); try { DependencyNode root = treeBuilder.buildDependencyTree(project.getPom(), localRepository, artifactFactory, artifactMetadataSource, null, artifactCollector); DependencyNodeVisitor visitor = new BuildingDependencyNodeVisitor(new DependencyNodeVisitor() { @Override public boolean visit(DependencyNode node) { return true; } @Override public boolean endVisit(DependencyNode node) { if (node.getParent() != null && node.getParent() != node) { saveDependency(project, node, context); } return true; } }); // mode verbose OFF : do not show the same lib many times DependencyNodeFilter filter = StateDependencyNodeFilter.INCLUDED; CollectingDependencyNodeVisitor collectingVisitor = new CollectingDependencyNodeVisitor(); DependencyNodeVisitor firstPassVisitor = new FilteringDependencyNodeVisitor(collectingVisitor, filter); root.accept(firstPassVisitor); DependencyNodeFilter secondPassFilter = new AncestorOrSelfDependencyNodeFilter(collectingVisitor.getNodes()); visitor = new FilteringDependencyNodeVisitor(visitor, secondPassFilter); root.accept(visitor); } catch (DependencyTreeBuilderException e) { throw new SonarException("Can not load the graph of dependencies of the project " + project.getKey(), e); } }
private Set<String> filterIncludedArtifacts(Set<String> artifacts) throws DependencyTreeBuilderException { Set<String> included = new TreeSet<>(); ArtifactFilter artifactFilter = new ScopeArtifactFilter(null); DependencyNode node = treeBuilder.buildDependencyTree(project, localRepository, artifactFactory, artifactMetadataSource, artifactFilter, artifactCollector); CollectingDependencyNodeVisitor visitor = new CollectingDependencyNodeVisitor(); node.accept(visitor); List<DependencyNode> nodes = visitor.getNodes(); for (DependencyNode dependencyNode : nodes) { Artifact artifact = dependencyNode.getArtifact(); if (getLog().isDebugEnabled()) { getLog().debug("Found dependency node: " + artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion() + " - scope=" + artifact.getScope()); } if (!Artifact.SCOPE_TEST.equals(artifact.getScope()) && !Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) { String canonicalName = artifact.getGroupId() + ":" + artifact.getArtifactId(); if (artifacts.contains(canonicalName)) { getLog().debug(canonicalName + " marked for exclusion"); included.add(canonicalName); } } } return included; }
visitor = new BuildingDependencyNodeVisitor( visitor ); CollectingDependencyNodeVisitor collectingVisitor = new CollectingDependencyNodeVisitor(); DependencyNodeVisitor firstPassVisitor = new FilteringDependencyNodeVisitor( collectingVisitor, StateDependencyNodeFilter.INCLUDED ); rootNode.accept( firstPassVisitor ); DependencyNodeFilter secondPassFilter = new AncestorOrSelfDependencyNodeFilter( collectingVisitor.getNodes() ); visitor = new FilteringDependencyNodeVisitor( visitor, secondPassFilter );
helper.getLog().debug("[victims-enforcer] artifact id of root = " + treeRoot.getArtifact().toString()); CollectingDependencyNodeVisitor visitor = new CollectingDependencyNodeVisitor(); treeRoot.accept(visitor); for (DependencyNode node : visitor.getNodes()){ if (node.getState() == DependencyNode.INCLUDED && ! treeRoot.equals(node)){ Artifact artifact = node.getArtifact();
throw new RuntimeException(e); CollectingDependencyNodeVisitor visitor = new CollectingDependencyNodeVisitor(); rootNode.accept(visitor); List<DependencyNode> nodes = visitor.getNodes(); List<ITypeLoader> deps = new ArrayList<>(); for (DependencyNode dependencyNode : nodes) {