From dfe9dcaa04e8fa10f053190f6448d415e1f1c5ec Mon Sep 17 00:00:00 2001 From: Sylwester Lachiewicz Date: Fri, 9 Oct 2026 21:56:46 +0200 Subject: [PATCH] Build the Maven dependency tree with Maven Resolver instead of maven-dependency-tree DependencyTreeFactory now collects the project graph with the Maven Resolver conflict resolver in verbose mode and returns a NetBeans-owned DependencyNode, so the unmaintained maven-dependency-tree 2.2 jar and its friend packages go. Assisted-by: Claude Opus 5.5 --- java/maven.embedder/apichanges.xml | 23 +- java/maven.embedder/external/binaries-list | 1 - .../maven-dependency-tree-2.2-license.txt | 208 ------------------ java/maven.embedder/manifest.mf | 2 +- .../nbproject/project.properties | 3 +- java/maven.embedder/nbproject/project.xml | 12 +- .../maven/embedder/DependencyTreeFactory.java | 167 ++++++++++---- .../modules/maven/embedder/MavenEmbedder.java | 9 + .../maven/embedder/tree/DependencyNode.java | 145 ++++++++++++ .../embedder/tree/DependencyNodeVisitor.java | 39 ++++ .../maven/embedder/tree/package-info.java | 24 ++ .../embedder/DependencyTreeFactoryTest.java | 171 ++++++++++++++ java/maven.graph/nbproject/project.xml | 2 +- .../graph/DependencyGraphTopComponent.java | 8 +- .../maven/graph/FixVersionConflictPanel.java | 2 +- .../modules/maven/graph/GraphConstructor.java | 2 +- .../modules/maven/graph/MavenAction.java | 2 +- .../maven/graph/MavenActionsProvider.java | 2 +- .../maven/graph/MavenDependencyNode.java | 12 +- java/maven.repository/nbproject/project.xml | 2 +- .../ui/ArtifactMultiViewFactory.java | 2 +- .../maven/repository/ui/DependencyPanel.java | 4 +- java/maven/nbproject/project.xml | 2 +- .../maven/actions/CreateLibraryAction.java | 2 +- .../maven/actions/CreateLibraryPanel.java | 4 +- .../DependencyExcludeNodeVisitor.java | 4 +- .../dependencies/ExcludeDependencyPanel.java | 2 +- .../modules/maven/nodes/DependencyNode.java | 10 +- .../MavenDependenciesImplementation.java | 24 +- .../maven/queries/MavenDependencyResult.java | 2 +- .../maven/spi/grammar/DialogFactory.java | 2 +- 31 files changed, 587 insertions(+), 307 deletions(-) delete mode 100644 java/maven.embedder/external/maven-dependency-tree-2.2-license.txt create mode 100644 java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNode.java create mode 100644 java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNodeVisitor.java create mode 100644 java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/package-info.java create mode 100644 java/maven.embedder/test/unit/src/org/netbeans/modules/maven/embedder/DependencyTreeFactoryTest.java diff --git a/java/maven.embedder/apichanges.xml b/java/maven.embedder/apichanges.xml index 732952052add..8011ea46d308 100644 --- a/java/maven.embedder/apichanges.xml +++ b/java/maven.embedder/apichanges.xml @@ -20,13 +20,13 @@ --> - + + + + Dependency tree no longer based on maven-dependency-tree + + + + + + DependencyTreeFactory + now builds the tree from Maven Resolver's verbose dependency graph and returns the new + org.netbeans.modules.maven.embedder.tree.DependencyNode, which offers the subset of the + former API that NetBeans used. The Maven Dependency Tree library is no longer bundled, and the + org.apache.maven.shared.dependency.* packages are no longer exported to friends. + Update imports to the new package; use the Maven Resolver API directly where the dependency graph is needed. + + + + + Multiple scopes allowed for dependency tree query diff --git a/java/maven.embedder/external/binaries-list b/java/maven.embedder/external/binaries-list index ef6babe93214..05bbcb1e58c0 100644 --- a/java/maven.embedder/external/binaries-list +++ b/java/maven.embedder/external/binaries-list @@ -15,5 +15,4 @@ # specific language governing permissions and limitations # under the License. DC15DFF8F701B227EE523EEB7A17F77C10EAFE2F org.jdom:jdom2:2.0.6.1 -5D9CE6ADD7B714B8095F0E3E396C5E9F8C5DCFEF org.apache.maven.shared:maven-dependency-tree:2.2 18E39B277439D736A03AF4C067AC51C26BCF7A95 org.apache.maven:apache-maven:3.9.16:bin@zip diff --git a/java/maven.embedder/external/maven-dependency-tree-2.2-license.txt b/java/maven.embedder/external/maven-dependency-tree-2.2-license.txt deleted file mode 100644 index 586232bf1ad0..000000000000 --- a/java/maven.embedder/external/maven-dependency-tree-2.2-license.txt +++ /dev/null @@ -1,208 +0,0 @@ -Name: Maven Dependency Tree -Version: 2.2 -Description: Maven Dependency Tree -License: Apache-2.0 -Origin: Apache Software Foundation -URL: https://maven.apache.org/ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/java/maven.embedder/manifest.mf b/java/maven.embedder/manifest.mf index 6f51129b4f59..095293b80b47 100644 --- a/java/maven.embedder/manifest.mf +++ b/java/maven.embedder/manifest.mf @@ -2,4 +2,4 @@ Manifest-Version: 1.0 OpenIDE-Module: org.netbeans.modules.maven.embedder/2 OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/embedder/Bundle.properties AutoUpdate-Show-In-Client: false -OpenIDE-Module-Specification-Version: 2.89 +OpenIDE-Module-Specification-Version: 2.90 diff --git a/java/maven.embedder/nbproject/project.properties b/java/maven.embedder/nbproject/project.properties index ba9db748173d..70d6cc6d1c0f 100644 --- a/java/maven.embedder/nbproject/project.properties +++ b/java/maven.embedder/nbproject/project.properties @@ -19,12 +19,11 @@ is.autoload=true javac.release=17 javac.compilerargs=-Xlint -Xlint:-serial release.external/jdom2-2.0.6.1.jar=modules/ext/maven/jdom2-2.0.6.1.jar -release.external/maven-dependency-tree-2.2.jar=modules/ext/maven/maven-dependency-tree-2.2.jar bundled.maven=apache-maven-3.9.16 extra.module.files=maven/ nbm.executable.files=maven/bin/mvn,maven/bin/mvnDebug,maven/bin/mvnyjp extra.license.files=${cluster}/maven/LICENSE.txt,${cluster}/maven/NOTICE.txt -module.javadoc.packages=org.netbeans.modules.maven.embedder +module.javadoc.packages=org.netbeans.modules.maven.embedder,org.netbeans.modules.maven.embedder.tree javadoc.apichanges=${basedir}/apichanges.xml javadoc.arch=${basedir}/arch.xml jnlp.indirect.files=modules/ext/maven/rootpackage/default-report.xml,modules/ext/maven/settings.xml diff --git a/java/maven.embedder/nbproject/project.xml b/java/maven.embedder/nbproject/project.xml index c53f48f76c96..53a24471037d 100644 --- a/java/maven.embedder/nbproject/project.xml +++ b/java/maven.embedder/nbproject/project.xml @@ -225,11 +225,6 @@ org.apache.maven.settings.building org.apache.maven.settings.crypto org.apache.maven.settings.io.xpp3 - org.apache.maven.shared.dependency.tree - org.apache.maven.shared.dependency.tree.traversal - org.apache.maven.shared.dependency.graph - org.apache.maven.shared.dependency.graph.filter - org.apache.maven.shared.dependency.graph.traversal org.apache.maven.wagon org.apache.maven.wagon.authentication org.apache.maven.wagon.authorization @@ -264,6 +259,7 @@ org.jdom2.util org.netbeans.modules.maven.embedder org.netbeans.modules.maven.embedder.exec + org.netbeans.modules.maven.embedder.tree org.eclipse.aether org.eclipse.aether.artifact @@ -309,12 +305,6 @@ org.apache.maven.wagon.shared.http org.apache.maven.wagon.providers.http.wagon.shared - - - ext/maven/maven-dependency-tree-2.2.jar - external/maven-dependency-tree-2.2.jar - - ext/maven/jdom2-2.0.6.1.jar external/jdom2-2.0.6.1.jar diff --git a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/DependencyTreeFactory.java b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/DependencyTreeFactory.java index 01251a25e088..d540c6d26e29 100644 --- a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/DependencyTreeFactory.java +++ b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/DependencyTreeFactory.java @@ -18,24 +18,44 @@ */ package org.netbeans.modules.maven.embedder; +import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; +import java.util.IdentityHashMap; import java.util.List; +import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; import org.apache.maven.MavenExecutionException; -import org.apache.maven.artifact.factory.ArtifactFactory; -import org.apache.maven.artifact.metadata.ArtifactMetadataSource; -import org.apache.maven.artifact.repository.ArtifactRepository; -import org.apache.maven.artifact.resolver.ArtifactCollector; +import org.apache.maven.RepositoryUtils; +import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.resolver.filter.ArtifactFilter; import org.apache.maven.artifact.resolver.filter.CumulativeScopeArtifactFilter; import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter; +import org.apache.maven.model.Dependency; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; -import org.apache.maven.shared.dependency.tree.DependencyTreeBuilder; -import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException; +import org.eclipse.aether.DefaultRepositorySystemSession; +import org.eclipse.aether.RepositorySystem; +import org.eclipse.aether.artifact.ArtifactTypeRegistry; +import org.eclipse.aether.collection.CollectRequest; +import org.eclipse.aether.collection.DependencyCollectionException; +import org.eclipse.aether.graph.DependencyNode; +import org.eclipse.aether.util.graph.manager.ClassicDependencyManager; +import org.eclipse.aether.util.graph.selector.AndDependencySelector; +import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector; +import org.eclipse.aether.util.graph.selector.OptionalDependencySelector; +import org.eclipse.aether.util.graph.selector.ScopeDependencySelector; +import org.eclipse.aether.util.graph.transformer.ConflictResolver; +import org.eclipse.aether.util.graph.transformer.JavaScopeDeriver; +import org.eclipse.aether.util.graph.transformer.JavaScopeSelector; +import org.eclipse.aether.util.graph.transformer.NearestVersionSelector; +import org.eclipse.aether.util.graph.transformer.SimpleOptionalitySelector; +import org.eclipse.aether.util.graph.traverser.FatArtifactTraverser; /** + * Builds the dependency tree of a project with Maven Resolver. The dependencies are collected with the + * conflict resolver in verbose mode, so that the nodes dropped by the conflict resolution stay in the graph + * and are reported as omitted. * * @author mkleint */ @@ -43,7 +63,7 @@ public class DependencyTreeFactory { private static final Logger LOG = Logger.getLogger(DependencyTreeFactory.class.getName()); @Deprecated - public static DependencyNode createDependencyTree(MavenProject project, MavenEmbedder embedder, String scope) { + public static org.netbeans.modules.maven.embedder.tree.DependencyNode createDependencyTree(MavenProject project, MavenEmbedder embedder, String scope) { try { return createDependencyTree(project, embedder, List.of(scope)); } catch (MavenExecutionException ex) { @@ -61,44 +81,117 @@ public static DependencyNode createDependencyTree(MavenProject project, MavenEmb * @throws MavenExecutionException wraps any maven-specific exception thrown by the implementation. * @since 2.71 */ - public static DependencyNode createDependencyTree(MavenProject project, MavenEmbedder embedder, Collection scopes) throws MavenExecutionException { - //TODO: check alternative for deprecated maven components - DependencyTreeBuilder builder = embedder.lookupComponent(DependencyTreeBuilder.class); - assert builder !=null : "DependencyTreeBuilder component not found in maven"; + public static org.netbeans.modules.maven.embedder.tree.DependencyNode createDependencyTree(MavenProject project, MavenEmbedder embedder, Collection scopes) throws MavenExecutionException { + RepositorySystem repositorySystem = embedder.lookupComponent(RepositorySystem.class); + assert repositorySystem != null : "RepositorySystem component not found in maven"; - ArtifactFactory factory = embedder.lookupComponent(ArtifactFactory.class); - assert factory !=null : "ArtifactFactory component not found in maven"; - - ArtifactMetadataSource source = embedder.lookupComponent(ArtifactMetadataSource.class); - assert source !=null : "ArtifactMetadataSource component not found in maven"; + embedder.setUpLegacySupport(); - ArtifactCollector collector = embedder.lookupComponent(ArtifactCollector.class); - assert collector !=null : "ArtifactCollector component not found in maven"; + DefaultRepositorySystemSession session = new DefaultRepositorySystemSession(embedder.newRepositorySession()); + configureVerboseSession(session); - embedder.setUpLegacySupport(); - - return createDependencyTree(project, builder, embedder.getLocalRepository(), factory, source, collector, scopes); + ArtifactTypeRegistry stereotypes = session.getArtifactTypeRegistry(); + CollectRequest request = new CollectRequest(); + request.setRootArtifact(RepositoryUtils.toArtifact(project.getArtifact())); + request.setRepositories(RepositoryUtils.toRepos(project.getRemoteArtifactRepositories())); + for (Dependency dependency : project.getDependencies()) { + request.addDependency(RepositoryUtils.toDependency(dependency, stereotypes)); + } + if (project.getDependencyManagement() != null) { + for (Dependency dependency : project.getDependencyManagement().getDependencies()) { + request.addManagedDependency(RepositoryUtils.toDependency(dependency, stereotypes)); + } + } - } - - //copied from dependency:tree mojo - private static DependencyNode createDependencyTree(MavenProject project, - DependencyTreeBuilder dependencyTreeBuilder, ArtifactRepository localRepository, - ArtifactFactory artifactFactory, ArtifactMetadataSource artifactMetadataSource, - ArtifactCollector artifactCollector, - Collection scopes) throws MavenExecutionException { - ArtifactFilter artifactFilter = createResolvingArtifactFilter(scopes); - try { - // TODO: note that filter does not get applied due to MNG-3236 - return dependencyTreeBuilder.buildDependencyTree(project, - localRepository, artifactFactory, - artifactMetadataSource, artifactFilter, artifactCollector); - } catch (DependencyTreeBuilderException exception) { + DependencyNode root = repositorySystem.collectDependencies(session, request).getRoot(); + return createDependencyTree(root, project.getArtifact(), createResolvingArtifactFilter(scopes)); + } catch (DependencyCollectionException exception) { throw new MavenExecutionException("Dependency tree scan failed", exception); } } + static void configureVerboseSession(DefaultRepositorySystemSession session) { + // keep the nodes dropped by the conflict resolution, marked with the winner + session.setDependencyGraphTransformer(new ConflictResolver( + new NearestVersionSelector(), + new JavaScopeSelector(), + new SimpleOptionalitySelector(), + new JavaScopeDeriver())); + session.setConfigProperty(ConflictResolver.CONFIG_PROP_VERBOSE, true); + // a session that was not created by Maven has none of the following + if (session.getDependencySelector() == null) { + session.setDependencySelector(new AndDependencySelector( + new ScopeDependencySelector("test", "provided"), + new OptionalDependencySelector(), + new ExclusionDependencySelector())); + } + if (session.getDependencyManager() == null) { + session.setDependencyManager(new ClassicDependencyManager()); + } + if (session.getDependencyTraverser() == null) { + session.setDependencyTraverser(new FatArtifactTraverser()); + } + } + + /** + * Maps the verbose graph collected by Maven Resolver to the tree. The nodes that lost the conflict + * resolution carry the winner in {@link ConflictResolver#NODE_DATA_WINNER} and have no children. + * A loser is {@link org.netbeans.modules.maven.embedder.tree.DependencyNode#OMITTED_FOR_CYCLE} if the winner is its ancestor, + * {@link org.netbeans.modules.maven.embedder.tree.DependencyNode#OMITTED_FOR_DUPLICATE} if the winner has the same version, and + * {@link org.netbeans.modules.maven.embedder.tree.DependencyNode#OMITTED_FOR_CONFLICT} otherwise. + * + * @param root the root of the collected graph + * @param rootArtifact the artifact of the project + * @param filter filters the dependencies, may be {@code null} + */ + static org.netbeans.modules.maven.embedder.tree.DependencyNode createDependencyTree(DependencyNode root, Artifact rootArtifact, ArtifactFilter filter) { + Set ancestors = Collections.newSetFromMap(new IdentityHashMap<>()); + return convert(root, rootArtifact, filter, ancestors, new ArrayList<>()); + } + + private static org.netbeans.modules.maven.embedder.tree.DependencyNode convert(DependencyNode node, Artifact artifact, + ArtifactFilter filter, Set ancestors, List trail) { + trail.add(artifact.getId()); + if (trail.size() > 1) { // do not modify the artifact of the project + artifact.setDependencyTrail(new ArrayList<>(trail)); + } + DependencyNode winner = (DependencyNode) node.getData().get(ConflictResolver.NODE_DATA_WINNER); + org.netbeans.modules.maven.embedder.tree.DependencyNode result; + if (winner == null) { + result = new org.netbeans.modules.maven.embedder.tree.DependencyNode(artifact); + } else if (ancestors.contains(winner)) { + result = new org.netbeans.modules.maven.embedder.tree.DependencyNode(artifact, + org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_CYCLE, null); + } else { + Artifact related = toArtifact(winner); + boolean sameVersion = winner.getArtifact().getBaseVersion().equals(node.getArtifact().getBaseVersion()); + result = new org.netbeans.modules.maven.embedder.tree.DependencyNode(artifact, + sameVersion ? org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_DUPLICATE + : org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_CONFLICT, + related); + } + ancestors.add(node); + for (DependencyNode child : node.getChildren()) { + Artifact childArtifact = toArtifact(child); + if (filter == null || filter.include(childArtifact)) { + result.addChild(convert(child, childArtifact, filter, ancestors, trail)); + } + } + ancestors.remove(node); + trail.remove(trail.size() - 1); + return result; + } + + private static Artifact toArtifact(DependencyNode node) { + Artifact artifact = RepositoryUtils.toArtifact(node.getArtifact()); + if (node.getDependency() != null) { + artifact.setScope(node.getDependency().getScope()); + artifact.setOptional(node.getDependency().isOptional()); + } + return artifact; + } + //copied from dependency:tree mojo /** * Gets the artifact filter to use when resolving the dependency tree. diff --git a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/MavenEmbedder.java b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/MavenEmbedder.java index 45691cccbf2d..1dcda2c634b4 100644 --- a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/MavenEmbedder.java +++ b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/MavenEmbedder.java @@ -439,6 +439,15 @@ public ProjectBuildingResult buildProject(Artifact art, ProjectBuildingRequest r return res; } + /** + * A fully configured repository session, resolving the reactor projects from the workspace. + */ + RepositorySystemSession newRepositorySession() { + MavenExecutionRequest request = createMavenExecutionRequest(); + request.setWorkspaceReader(new NbWorkspaceReader(versionResolver)); + return maven.newRepositorySession(request); + } + public MavenExecutionResult execute(MavenExecutionRequest req) { return maven.execute(req); } diff --git a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNode.java b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNode.java new file mode 100644 index 000000000000..abc612948532 --- /dev/null +++ b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNode.java @@ -0,0 +1,145 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.netbeans.modules.maven.embedder.tree; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import org.apache.maven.artifact.Artifact; + +/** + * A node of the resolved dependency tree. Replaces the node type of the + * legacy Maven Dependency Tree library and keeps the subset of its API that NetBeans uses. + * Nodes use identity for {@code equals} and {@code hashCode}. + * + * @since 2.90 + */ +public final class DependencyNode { + + /** The artifact is part of the resolved dependencies. */ + public static final int INCLUDED = 0; + + /** The artifact was omitted because the same version is already in the tree. */ + public static final int OMITTED_FOR_DUPLICATE = 1; + + /** The artifact was omitted because another version of it won the conflict resolution. */ + public static final int OMITTED_FOR_CONFLICT = 2; + + /** The artifact was omitted because it is an ancestor of itself. */ + public static final int OMITTED_FOR_CYCLE = 3; + + private final Artifact artifact; + private final int state; + private final Artifact relatedArtifact; + private final List children = new ArrayList<>(); + private DependencyNode parent; + + /** + * Creates an included node. + * @param artifact the artifact of the node + */ + public DependencyNode(Artifact artifact) { + this(artifact, INCLUDED, null); + } + + /** + * Creates a node. + * @param artifact the artifact of the node + * @param state one of the state constants + * @param relatedArtifact the artifact that won the conflict or duplicates this one; {@code null} for {@link #INCLUDED} + */ + public DependencyNode(Artifact artifact, int state, Artifact relatedArtifact) { + this.artifact = artifact; + this.state = state; + this.relatedArtifact = relatedArtifact; + } + + /** + * Visits this node and, while the visitor returns {@code true}, its descendants. + * @param visitor the visitor + * @return the result of {@link DependencyNodeVisitor#endVisit} + */ + public boolean accept(DependencyNodeVisitor visitor) { + if (visitor.visit(this)) { + for (DependencyNode child : children) { + if (!child.accept(visitor)) { + break; + } + } + } + return visitor.endVisit(this); + } + + public void addChild(DependencyNode child) { + children.add(child); + child.parent = this; + } + + public void removeChild(DependencyNode child) { + children.remove(child); + child.parent = null; + } + + public DependencyNode getParent() { + return parent; + } + + public Artifact getArtifact() { + return artifact; + } + + /** + * @return the number of ancestors, 0 for the root + */ + public int getDepth() { + int depth = 0; + for (DependencyNode p = parent; p != null; p = p.parent) { + depth++; + } + return depth; + } + + /** + * @return an unmodifiable view of the children + */ + public List getChildren() { + return Collections.unmodifiableList(children); + } + + public boolean hasChildren() { + return !children.isEmpty(); + } + + public int getState() { + return state; + } + + /** + * @return the artifact that won the conflict (for {@link #OMITTED_FOR_CONFLICT}) or the one this + * node duplicates, {@code null} for {@link #INCLUDED} + */ + public Artifact getRelatedArtifact() { + return relatedArtifact; + } + + @Override + public String toString() { + return artifact + (state == INCLUDED ? "" : " (omitted, state " + state + ")"); + } +} diff --git a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNodeVisitor.java b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNodeVisitor.java new file mode 100644 index 000000000000..ff99033a6d12 --- /dev/null +++ b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/DependencyNodeVisitor.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.netbeans.modules.maven.embedder.tree; + +/** + * Visits the nodes of a dependency tree in pre-order. + * + * @since 2.90 + */ +public interface DependencyNodeVisitor { + + /** + * @param node the node being entered + * @return {@code true} to visit the children of the node + */ + boolean visit(DependencyNode node); + + /** + * @param node the node whose subtree was visited + * @return {@code true} to continue with the next sibling + */ + boolean endVisit(DependencyNode node); +} diff --git a/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/package-info.java b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/package-info.java new file mode 100644 index 000000000000..0c83455d7db5 --- /dev/null +++ b/java/maven.embedder/src/org/netbeans/modules/maven/embedder/tree/package-info.java @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/** + * The dependency tree model returned by + * {@link org.netbeans.modules.maven.embedder.DependencyTreeFactory}. + */ +package org.netbeans.modules.maven.embedder.tree; diff --git a/java/maven.embedder/test/unit/src/org/netbeans/modules/maven/embedder/DependencyTreeFactoryTest.java b/java/maven.embedder/test/unit/src/org/netbeans/modules/maven/embedder/DependencyTreeFactoryTest.java new file mode 100644 index 000000000000..bb5af7acca4f --- /dev/null +++ b/java/maven.embedder/test/unit/src/org/netbeans/modules/maven/embedder/DependencyTreeFactoryTest.java @@ -0,0 +1,171 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.netbeans.modules.maven.embedder; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.apache.maven.RepositoryUtils; +import org.apache.maven.artifact.Artifact; +import org.eclipse.aether.DefaultRepositorySystemSession; +import org.eclipse.aether.RepositorySystemSession; +import org.eclipse.aether.artifact.DefaultArtifact; +import org.eclipse.aether.collection.DependencyGraphTransformationContext; +import org.eclipse.aether.graph.DefaultDependencyNode; +import org.eclipse.aether.graph.Dependency; +import org.eclipse.aether.graph.DependencyNode; +import org.eclipse.aether.util.graph.transformer.ConflictResolver; +import org.eclipse.aether.util.version.GenericVersionScheme; +import org.eclipse.aether.version.InvalidVersionSpecificationException; +import org.junit.Test; +import static org.junit.Assert.*; +import static org.netbeans.modules.maven.embedder.tree.DependencyNode.INCLUDED; +import static org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_CONFLICT; +import static org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_CYCLE; +import static org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_DUPLICATE; + +/** + * Maps a graph that went through the conflict resolver configured by {@link DependencyTreeFactory}. + */ +public class DependencyTreeFactoryTest { + + private static final GenericVersionScheme SCHEME = new GenericVersionScheme(); + + private static DependencyNode node(String artifactId, String version, DependencyNode... children) throws InvalidVersionSpecificationException { + DefaultDependencyNode n = new DefaultDependencyNode( + new Dependency(new DefaultArtifact("g", artifactId, "jar", version), "compile")); + n.setVersion(SCHEME.parseVersion(version)); + n.setVersionConstraint(SCHEME.parseVersionConstraint(version)); + n.setChildren(new ArrayList<>(List.of(children))); + return n; + } + + private static org.netbeans.modules.maven.embedder.tree.DependencyNode tree(DependencyNode root) throws Exception { + DefaultRepositorySystemSession session = new DefaultRepositorySystemSession(); + DependencyTreeFactory.configureVerboseSession(session); + Map data = new HashMap<>(); + session.getDependencyGraphTransformer().transformGraph(root, new DependencyGraphTransformationContext() { + @Override + public RepositorySystemSession getSession() { + return session; + } + @Override + public Object get(Object key) { + return data.get(key); + } + @Override + public Object put(Object key, Object value) { + return data.put(key, value); + } + }); + Artifact project = RepositoryUtils.toArtifact(root.getArtifact()); + return DependencyTreeFactory.createDependencyTree(root, project, null); + } + + private static org.netbeans.modules.maven.embedder.tree.DependencyNode child( + org.netbeans.modules.maven.embedder.tree.DependencyNode parent, String artifactId, int index) { + List found = new ArrayList<>(); + for (org.netbeans.modules.maven.embedder.tree.DependencyNode c : parent.getChildren()) { + if (c.getArtifact().getArtifactId().equals(artifactId)) { + found.add(c); + } + } + return found.get(index); + } + + @Test + public void conflictLoserIsOmittedForConflictWithWinnerAsRelatedArtifact() throws Exception { + // c:1 is nearer than c:2, so c:2 loses + DependencyNode root = node("root", "1.0", node("c", "1.0"), node("a", "1.0", node("c", "2.0"))); + org.netbeans.modules.maven.embedder.tree.DependencyNode tree = tree(root); + + org.netbeans.modules.maven.embedder.tree.DependencyNode winner = child(tree, "c", 0); + assertEquals(INCLUDED, winner.getState()); + assertNull(winner.getRelatedArtifact()); + + org.netbeans.modules.maven.embedder.tree.DependencyNode loser = child(child(tree, "a", 0), "c", 0); + assertEquals("2.0", loser.getArtifact().getVersion()); + assertEquals(OMITTED_FOR_CONFLICT, loser.getState()); + assertNotNull(loser.getRelatedArtifact()); + assertEquals("1.0", loser.getRelatedArtifact().getVersion()); + assertEquals(loser.getArtifact().getDependencyConflictId(), loser.getRelatedArtifact().getDependencyConflictId()); + assertFalse(loser.hasChildren()); + assertEquals(2, loser.getDepth()); + assertEquals("compile", loser.getArtifact().getScope()); + } + + @Test + public void sameVersionLoserIsOmittedForDuplicate() throws Exception { + DependencyNode root = node("root", "1.0", node("c", "1.0"), node("a", "1.0", node("c", "1.0"))); + org.netbeans.modules.maven.embedder.tree.DependencyNode tree = tree(root); + + assertEquals(INCLUDED, child(tree, "c", 0).getState()); + org.netbeans.modules.maven.embedder.tree.DependencyNode dup = child(child(tree, "a", 0), "c", 0); + assertEquals(OMITTED_FOR_DUPLICATE, dup.getState()); + assertEquals("1.0", dup.getRelatedArtifact().getVersion()); + assertFalse(dup.hasChildren()); + } + + @Test + public void winnerKeepsItsChildren() throws Exception { + DependencyNode root = node("root", "1.0", node("a", "1.0", node("d", "1.0"))); + org.netbeans.modules.maven.embedder.tree.DependencyNode tree = tree(root); + org.netbeans.modules.maven.embedder.tree.DependencyNode d = child(child(tree, "a", 0), "d", 0); + assertEquals(INCLUDED, d.getState()); + assertSame(tree, d.getParent().getParent()); + } + + @Test + public void loserWhoseWinnerIsAnAncestorIsOmittedForCycle() throws Exception { + // root -> a -> b -> a' where a' is a loser of a, as if the conflict resolver had kept it + DependencyNode a = node("a", "1.0"); + DependencyNode b = node("b", "1.0"); + DefaultDependencyNode again = (DefaultDependencyNode) node("a", "1.0"); + again.setData(ConflictResolver.NODE_DATA_WINNER, a); + b.setChildren(new ArrayList<>(List.of(again))); + a.setChildren(new ArrayList<>(List.of(b))); + DependencyNode root = node("root", "1.0", a); + + org.netbeans.modules.maven.embedder.tree.DependencyNode tree = DependencyTreeFactory.createDependencyTree( + root, RepositoryUtils.toArtifact(root.getArtifact()), null); + + org.netbeans.modules.maven.embedder.tree.DependencyNode cycle = child(child(child(tree, "a", 0), "b", 0), "a", 0); + assertEquals(OMITTED_FOR_CYCLE, cycle.getState()); + assertNull(cycle.getRelatedArtifact()); + } + + @Test + public void conflictResolverCutsCyclesSoTheTreeEnds() throws Exception { + DependencyNode a = node("a", "1.0"); + DependencyNode b = node("b", "1.0"); + DependencyNode again = node("a", "1.0"); + List aChildren = new ArrayList<>(List.of(b)); + a.setChildren(aChildren); + b.setChildren(new ArrayList<>(List.of(again))); + // like the collector, the repeated node shares the children of the ancestor + again.setChildren(aChildren); + + org.netbeans.modules.maven.embedder.tree.DependencyNode tree = tree(node("root", "1.0", a)); + + org.netbeans.modules.maven.embedder.tree.DependencyNode bNode = child(child(tree, "a", 0), "b", 0); + assertEquals(INCLUDED, bNode.getState()); + assertFalse(bNode.hasChildren()); + } +} diff --git a/java/maven.graph/nbproject/project.xml b/java/maven.graph/nbproject/project.xml index 823d736d3232..8df1b6634e41 100644 --- a/java/maven.graph/nbproject/project.xml +++ b/java/maven.graph/nbproject/project.xml @@ -75,7 +75,7 @@ 2 - 2.54 + 2.90 diff --git a/java/maven.graph/src/org/netbeans/modules/maven/graph/DependencyGraphTopComponent.java b/java/maven.graph/src/org/netbeans/modules/maven/graph/DependencyGraphTopComponent.java index e31eac9cae44..7acee60fedad 100644 --- a/java/maven.graph/src/org/netbeans/modules/maven/graph/DependencyGraphTopComponent.java +++ b/java/maven.graph/src/org/netbeans/modules/maven/graph/DependencyGraphTopComponent.java @@ -61,7 +61,7 @@ import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.InvalidArtifactRTException; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.annotations.common.StaticResource; import org.netbeans.api.project.FileOwnerQuery; import org.netbeans.api.project.Project; @@ -192,7 +192,7 @@ private void reset() { } // private Project project; - private Lookup.Result result; + private Lookup.Result result; private Lookup.Result result2; private Lookup.Result result3; @@ -308,7 +308,7 @@ public int getPersistenceType() { super.componentOpened(); pane.setWheelScrollingEnabled(true); add(pane, BorderLayout.CENTER); - result = getLookup().lookupResult(org.apache.maven.shared.dependency.tree.DependencyNode.class); + result = getLookup().lookupResult(org.netbeans.modules.maven.embedder.tree.DependencyNode.class); result.addLookupListener(this); result2 = getLookup().lookupResult(MavenProject.class); result2.addLookupListener(this); @@ -540,7 +540,7 @@ private void waitForApproval() { }) private void createScene() { - Iterator it1 = result.allInstances().iterator(); + Iterator it1 = result.allInstances().iterator(); Iterator it2 = result2.allInstances().iterator(); Iterator it3 = result3.allInstances().iterator(); final MavenProject prj = it2.hasNext() ? it2.next() : null; diff --git a/java/maven.graph/src/org/netbeans/modules/maven/graph/FixVersionConflictPanel.java b/java/maven.graph/src/org/netbeans/modules/maven/graph/FixVersionConflictPanel.java index 2fdac944d5d1..0c274bc9672c 100644 --- a/java/maven.graph/src/org/netbeans/modules/maven/graph/FixVersionConflictPanel.java +++ b/java/maven.graph/src/org/netbeans/modules/maven/graph/FixVersionConflictPanel.java @@ -42,7 +42,7 @@ import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.versioning.ArtifactVersion; import org.apache.maven.artifact.versioning.DefaultArtifactVersion; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import static org.netbeans.modules.maven.graph.Bundle.*; import org.openide.util.NbBundle.Messages; import org.netbeans.modules.java.graph.GraphNodeImplementation; diff --git a/java/maven.graph/src/org/netbeans/modules/maven/graph/GraphConstructor.java b/java/maven.graph/src/org/netbeans/modules/maven/graph/GraphConstructor.java index 995d53634665..dcdea2a35ccd 100644 --- a/java/maven.graph/src/org/netbeans/modules/maven/graph/GraphConstructor.java +++ b/java/maven.graph/src/org/netbeans/modules/maven/graph/GraphConstructor.java @@ -29,7 +29,7 @@ import org.apache.maven.model.Dependency; import org.apache.maven.model.DependencyManagement; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.modules.java.graph.GraphEdge; import org.netbeans.modules.java.graph.GraphNode; import org.netbeans.modules.java.graph.DependencyGraphScene; diff --git a/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenAction.java b/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenAction.java index e36a6a248721..4fd25e5d47ce 100644 --- a/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenAction.java +++ b/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenAction.java @@ -32,7 +32,7 @@ import org.apache.maven.artifact.versioning.ArtifactVersion; import org.apache.maven.artifact.versioning.DefaultArtifactVersion; import org.apache.maven.model.Profile; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.project.Project; import org.netbeans.modules.maven.api.NbMavenProject; import org.netbeans.modules.maven.model.pom.Dependency; diff --git a/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenActionsProvider.java b/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenActionsProvider.java index 79352126a8f7..1913929e8f07 100644 --- a/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenActionsProvider.java +++ b/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenActionsProvider.java @@ -22,7 +22,7 @@ import org.netbeans.modules.java.graph.DependencyGraphScene; import java.util.Set; import javax.swing.Action; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.project.Project; import org.netbeans.modules.maven.api.CommonArtifactActions; import org.netbeans.modules.maven.api.NbMavenProject; diff --git a/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenDependencyNode.java b/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenDependencyNode.java index f52ce5525df9..87bbf5b5b80b 100644 --- a/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenDependencyNode.java +++ b/java/maven.graph/src/org/netbeans/modules/maven/graph/MavenDependencyNode.java @@ -37,18 +37,18 @@ public class MavenDependencyNode implements GraphNodeImplementation { static final Color COMPILE = new Color(191, 191, 255); static final Color RUNTIME = new Color(191, 255, 191); static final Color TEST = new Color(202, 151, 151); - private final org.apache.maven.shared.dependency.tree.DependencyNode dependencyNode; + private final org.netbeans.modules.maven.embedder.tree.DependencyNode dependencyNode; private DefaultArtifactVersion version; private List scopes; private MavenDependencyNode parent; - private final HashMap children = new HashMap<>(); + private final HashMap children = new HashMap<>(); - public MavenDependencyNode(org.apache.maven.shared.dependency.tree.DependencyNode dependencyNode) { + public MavenDependencyNode(org.netbeans.modules.maven.embedder.tree.DependencyNode dependencyNode) { this(null, dependencyNode); } - private MavenDependencyNode(MavenDependencyNode parent, org.apache.maven.shared.dependency.tree.DependencyNode dependencyNode) { + private MavenDependencyNode(MavenDependencyNode parent, org.netbeans.modules.maven.embedder.tree.DependencyNode dependencyNode) { this.dependencyNode = dependencyNode; this.parent = parent; } @@ -117,7 +117,7 @@ public String getTooltipText() { @Override public MavenDependencyNode getParent() { - org.apache.maven.shared.dependency.tree.DependencyNode p = dependencyNode.getParent(); + org.netbeans.modules.maven.embedder.tree.DependencyNode p = dependencyNode.getParent(); if(parent == null) { parent = p != null ? new MavenDependencyNode(dependencyNode.getParent()) : null; } @@ -140,7 +140,7 @@ public String getRelatedDependencyConflictId() { public List getChildren() { synchronized(children) { List ret = new ArrayList<>(); - for (org.apache.maven.shared.dependency.tree.DependencyNode n : dependencyNode.getChildren()) { + for (org.netbeans.modules.maven.embedder.tree.DependencyNode n : dependencyNode.getChildren()) { MavenDependencyNode mn = children.get(n); if(mn == null) { mn = new MavenDependencyNode(this, n); diff --git a/java/maven.repository/nbproject/project.xml b/java/maven.repository/nbproject/project.xml index b5c0634e59fa..aa088b2ba060 100644 --- a/java/maven.repository/nbproject/project.xml +++ b/java/maven.repository/nbproject/project.xml @@ -76,7 +76,7 @@ 2 - 2.77 + 2.90 diff --git a/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/ArtifactMultiViewFactory.java b/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/ArtifactMultiViewFactory.java index 263d0900d345..bfbaa3b0a0fd 100644 --- a/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/ArtifactMultiViewFactory.java +++ b/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/ArtifactMultiViewFactory.java @@ -40,7 +40,7 @@ import org.apache.maven.project.ProjectBuildingRequest; import org.apache.maven.project.ProjectBuildingResult; import org.apache.maven.repository.RepositorySystem; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.annotations.common.CheckForNull; import org.netbeans.api.annotations.common.NonNull; import org.netbeans.api.annotations.common.NullAllowed; diff --git a/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/DependencyPanel.java b/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/DependencyPanel.java index b60948b5d5b3..1575b2ce44fa 100644 --- a/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/DependencyPanel.java +++ b/java/maven.repository/src/org/netbeans/modules/maven/repository/ui/DependencyPanel.java @@ -46,8 +46,8 @@ import javax.swing.tree.TreeSelectionModel; import org.apache.maven.artifact.Artifact; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; -import org.apache.maven.shared.dependency.tree.traversal.DependencyNodeVisitor; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNodeVisitor; import org.netbeans.api.project.FileOwnerQuery; import org.netbeans.api.project.Project; import org.netbeans.core.spi.multiview.CloseOperationState; diff --git a/java/maven/nbproject/project.xml b/java/maven/nbproject/project.xml index 94ff3287ed83..b543f12ddd87 100644 --- a/java/maven/nbproject/project.xml +++ b/java/maven/nbproject/project.xml @@ -219,7 +219,7 @@ 2 - 2.77 + 2.90 diff --git a/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryAction.java b/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryAction.java index 0ac405f5f7cc..6d6c14c2e271 100644 --- a/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryAction.java +++ b/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryAction.java @@ -40,7 +40,7 @@ import org.netbeans.api.annotations.common.SuppressWarnings; import org.netbeans.modules.maven.embedder.MavenEmbedder; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.annotations.common.CheckForNull; import org.netbeans.api.annotations.common.StaticResource; import org.netbeans.api.progress.ProgressHandle; diff --git a/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryPanel.java b/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryPanel.java index 439f109b31d6..6fe373532111 100644 --- a/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryPanel.java +++ b/java/maven/src/org/netbeans/modules/maven/actions/CreateLibraryPanel.java @@ -34,8 +34,8 @@ import javax.swing.tree.DefaultTreeModel; import javax.swing.tree.TreeNode; import org.apache.maven.artifact.Artifact; -import org.apache.maven.shared.dependency.tree.DependencyNode; -import org.apache.maven.shared.dependency.tree.traversal.DependencyNodeVisitor; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNodeVisitor; import org.netbeans.api.project.libraries.LibraryManager; import org.netbeans.api.validation.adapters.DialogDescriptorAdapter; import org.netbeans.api.validation.adapters.NotificationLineSupportAdapter; diff --git a/java/maven/src/org/netbeans/modules/maven/dependencies/DependencyExcludeNodeVisitor.java b/java/maven/src/org/netbeans/modules/maven/dependencies/DependencyExcludeNodeVisitor.java index 79a6593e0334..f24086982f87 100644 --- a/java/maven/src/org/netbeans/modules/maven/dependencies/DependencyExcludeNodeVisitor.java +++ b/java/maven/src/org/netbeans/modules/maven/dependencies/DependencyExcludeNodeVisitor.java @@ -23,8 +23,8 @@ import java.util.Set; import java.util.Stack; import org.apache.maven.artifact.Artifact; -import org.apache.maven.shared.dependency.tree.DependencyNode; -import org.apache.maven.shared.dependency.tree.traversal.DependencyNodeVisitor; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNodeVisitor; /** * diff --git a/java/maven/src/org/netbeans/modules/maven/dependencies/ExcludeDependencyPanel.java b/java/maven/src/org/netbeans/modules/maven/dependencies/ExcludeDependencyPanel.java index 66c27cc4ba2e..d0492300baa5 100644 --- a/java/maven/src/org/netbeans/modules/maven/dependencies/ExcludeDependencyPanel.java +++ b/java/maven/src/org/netbeans/modules/maven/dependencies/ExcludeDependencyPanel.java @@ -44,7 +44,7 @@ import org.apache.maven.MavenExecutionException; import org.apache.maven.artifact.Artifact; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.modules.maven.embedder.DependencyTreeFactory; import org.netbeans.modules.maven.embedder.EmbedderFactory; import org.netbeans.modules.maven.spi.IconResources; diff --git a/java/maven/src/org/netbeans/modules/maven/nodes/DependencyNode.java b/java/maven/src/org/netbeans/modules/maven/nodes/DependencyNode.java index 64edd08b29ad..85662fe14bb8 100644 --- a/java/maven/src/org/netbeans/modules/maven/nodes/DependencyNode.java +++ b/java/maven/src/org/netbeans/modules/maven/nodes/DependencyNode.java @@ -915,7 +915,7 @@ public void actionPerformed(ActionEvent event) { RP.post(new Runnable() { @Override public void run() { - org.apache.maven.shared.dependency.tree.DependencyNode rootnode; + org.netbeans.modules.maven.embedder.tree.DependencyNode rootnode; try { rootnode = DependencyTreeFactory.createDependencyTree(data.getMavenProject(), EmbedderFactory.getOnlineEmbedder(), List.of(Artifact.SCOPE_TEST)); } catch (MavenExecutionException ex) { @@ -924,8 +924,8 @@ public void run() { } DependencyExcludeNodeVisitor nv = new DependencyExcludeNodeVisitor(data.art.getGroupId(), data.art.getArtifactId(), data.art.getType()); rootnode.accept(nv); - final Set nds = nv.getDirectDependencies(); - Collection directs; + final Set nds = nv.getDirectDependencies(); + Collection directs; if (nds.size() > 1) { final ExcludeDependencyPanel pnl = new ExcludeDependencyPanel(data.getMavenProject(), data.art, nds, rootnode); DialogDescriptor dd = new DialogDescriptor(pnl, TIT_Exclude()); @@ -943,11 +943,11 @@ public void run() { }); } - private void runModifyExclusions(final Artifact art, final Collection nds) { + private void runModifyExclusions(final Artifact art, final Collection nds) { ModelOperation operation = new ModelOperation() { @Override public void performOperation(POMModel model) { - for (org.apache.maven.shared.dependency.tree.DependencyNode nd : nds) { + for (org.netbeans.modules.maven.embedder.tree.DependencyNode nd : nds) { Artifact directArt = nd.getArtifact(); org.netbeans.modules.maven.model.pom.Dependency dep = model.getProject().findDependencyById(directArt.getGroupId(), directArt.getArtifactId(), null); if (dep == null) { diff --git a/java/maven/src/org/netbeans/modules/maven/queries/MavenDependenciesImplementation.java b/java/maven/src/org/netbeans/modules/maven/queries/MavenDependenciesImplementation.java index b513bab7b8e7..cb46e2efb554 100644 --- a/java/maven/src/org/netbeans/modules/maven/queries/MavenDependenciesImplementation.java +++ b/java/maven/src/org/netbeans/modules/maven/queries/MavenDependenciesImplementation.java @@ -275,7 +275,7 @@ public DependencyResult findDependencies(ProjectDependencies.DependencyQuery que filter(Objects::nonNull). collect(Collectors.toList()); - org.apache.maven.shared.dependency.tree.DependencyNode n; + org.netbeans.modules.maven.embedder.tree.DependencyNode n; try { n = DependencyTreeFactory.createDependencyTree(mp, embedder, mavenScopes); } catch (MavenExecutionException ex) { @@ -351,7 +351,7 @@ private static String getFullArtifactId(Artifact a) { } private class Converter { - final Map> realNodes = new HashMap<>(); + final Map> realNodes = new HashMap<>(); final Dependency.Filter filter; final Set broken = new HashSet<>(); List annotationProcessors = Collections.emptyList(); @@ -360,30 +360,30 @@ public Converter(Dependency.Filter filter) { this.filter = filter; } - private void findRealNodes(org.apache.maven.shared.dependency.tree.DependencyNode n) { + private void findRealNodes(org.netbeans.modules.maven.embedder.tree.DependencyNode n) { if (n.getArtifact() == null) { return; } Artifact a = n.getArtifact(); - if (n.getState() != org.apache.maven.shared.dependency.tree.DependencyNode.INCLUDED) { + if (n.getState() != org.netbeans.modules.maven.embedder.tree.DependencyNode.INCLUDED) { return; } // register (if not present) using plain artifact ID, but also using the full path, which will be preferred for the lookup. realNodes.putIfAbsent(a.getId(), n.getChildren()); realNodes.put(getFullArtifactId(a), n.getChildren()); - for (org.apache.maven.shared.dependency.tree.DependencyNode c : n.getChildren()) { + for (org.netbeans.modules.maven.embedder.tree.DependencyNode c : n.getChildren()) { findRealNodes(c); } } - private Dependency convertDependencies(org.apache.maven.shared.dependency.tree.DependencyNode n) { + private Dependency convertDependencies(org.netbeans.modules.maven.embedder.tree.DependencyNode n) { findRealNodes(n); return convert2(true, n, new HashSet<>()); } - private Dependency convert2(boolean root, org.apache.maven.shared.dependency.tree.DependencyNode n, Set visited) { + private Dependency convert2(boolean root, org.netbeans.modules.maven.embedder.tree.DependencyNode n, Set visited) { List ch = new ArrayList<>(); ArtifactSpec currentArtifact = mavenToArtifactSpec(n.getArtifact()); @@ -393,13 +393,13 @@ private Dependency convert2(boolean root, org.apache.maven.shared.dependency.tre return null; } - List children = n.getChildren(); + List children = n.getChildren(); org.apache.maven.artifact.Artifact thisArtifact = n.getArtifact(); org.apache.maven.artifact.Artifact relatedArtifact = n.getRelatedArtifact(); switch (n.getState()) { - case org.apache.maven.shared.dependency.tree.DependencyNode.OMITTED_FOR_CYCLE: - case org.apache.maven.shared.dependency.tree.DependencyNode.OMITTED_FOR_DUPLICATE: + case org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_CYCLE: + case org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_DUPLICATE: // TODO: unless the client specifies NOT to eliminate duplicates from the tree, // we need to include the duplicate including the children, to form a correct full dependency tree. if (relatedArtifact != null) { @@ -409,7 +409,7 @@ private Dependency convert2(boolean root, org.apache.maven.shared.dependency.tre children = realNodes.getOrDefault(n.getArtifact().getId(), n.getChildren()); } break; - case org.apache.maven.shared.dependency.tree.DependencyNode.OMITTED_FOR_CONFLICT: + case org.netbeans.modules.maven.embedder.tree.DependencyNode.OMITTED_FOR_CONFLICT: // there are two cases when OMITTED_FOR_CONFLICT is used: // 1. another version is actually used, which means that unless the client requests to omit // duplicates, we need to include the ACTUAL dependency's artifact version and its children. @@ -442,7 +442,7 @@ private Dependency convert2(boolean root, org.apache.maven.shared.dependency.tre } } - for (org.apache.maven.shared.dependency.tree.DependencyNode c : children) { + for (org.netbeans.modules.maven.embedder.tree.DependencyNode c : children) { Dependency cd = convert2(false, c, visited); if (cd != null) { ch.add(cd); diff --git a/java/maven/src/org/netbeans/modules/maven/queries/MavenDependencyResult.java b/java/maven/src/org/netbeans/modules/maven/queries/MavenDependencyResult.java index e2ff664cdd9f..7a64708bd37f 100644 --- a/java/maven/src/org/netbeans/modules/maven/queries/MavenDependencyResult.java +++ b/java/maven/src/org/netbeans/modules/maven/queries/MavenDependencyResult.java @@ -42,7 +42,7 @@ import org.apache.maven.model.building.ModelBuildingException; import org.apache.maven.model.building.ModelBuildingResult; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.editor.document.LineDocument; import org.netbeans.api.editor.document.LineDocumentUtils; import org.netbeans.api.project.Project; diff --git a/java/maven/src/org/netbeans/modules/maven/spi/grammar/DialogFactory.java b/java/maven/src/org/netbeans/modules/maven/spi/grammar/DialogFactory.java index a80e19dd1c79..967ef9d26165 100644 --- a/java/maven/src/org/netbeans/modules/maven/spi/grammar/DialogFactory.java +++ b/java/maven/src/org/netbeans/modules/maven/spi/grammar/DialogFactory.java @@ -23,7 +23,7 @@ import java.util.List; import java.util.Map; import org.apache.maven.artifact.Artifact; -import org.apache.maven.shared.dependency.tree.DependencyNode; +import org.netbeans.modules.maven.embedder.tree.DependencyNode; import org.netbeans.api.project.Project; import org.netbeans.modules.maven.api.NbMavenProject; import org.netbeans.modules.maven.dependencies.ExcludeDependencyPanel;