Add Proxy/Proxies data model to MavenSettings (#7092)

* Add Proxy/Proxies data model to MavenSettings

Add support for parsing proxy settings from Maven's settings.xml. This
adds the Proxies and Proxy inner classes following the existing Servers/Server
pattern, including merge, interpolation, and password decryption support.

* Make Proxy.id non-nullable to fix silent data loss in Proxies.merge()

Proxy.id was @nullable but used as a LinkedHashMap key in merge(),
causing proxies with null ids to silently overwrite each other.
This aligns with Server.id which is already non-nullable.

* Address PR review: make Proxy.id and Proxy.port nullable per Maven defaults

Per reviewer feedback, Proxy.id and Proxy.port now match Maven's settings
schema where id defaults to "default" and port defaults to 8080. Both are
now @nullable to accurately represent when values are omitted from XML.

Proxies.merge() is updated to handle null ids by assigning synthetic keys,
preventing silent data loss when multiple proxies omit the id element.

Author: timtebeek

rewrite-maven/src/main/java/org/openrewrite/maven/MavenSettings.java

@@ -73,15 +73,25 @@ public class MavenSettings {
     @With
     Servers servers;
 
-    @JsonCreator
+    @Nullable
+    Proxies proxies;
+
     public MavenSettings(@Nullable String localRepository, @Nullable Profiles profiles,
                          @Nullable ActiveProfiles activeProfiles, @Nullable Mirrors mirrors,
                          @Nullable Servers servers) {
+        this(localRepository, profiles, activeProfiles, mirrors, servers, null);
+    }
+
+    @JsonCreator
+    public MavenSettings(@Nullable String localRepository, @Nullable Profiles profiles,
+                         @Nullable ActiveProfiles activeProfiles, @Nullable Mirrors mirrors,
+                         @Nullable Servers servers, @Nullable Proxies proxies) {
         this.localRepository = localRepository;
         this.profiles = profiles;
         this.activeProfiles = activeProfiles;
         this.mirrors = mirrors;
         this.servers = servers;
+        this.proxies = proxies;
     }
 
     public static @Nullable MavenSettings parse(Parser.Input source, ExecutionContext ctx) {
@@ -148,6 +158,12 @@ void maybeDecryptPasswords(ExecutionContext ctx) {
                     return password == null ? server : server.withPassword(password);
                 });
             }
+            if (proxies != null) {
+                proxies.proxies = ListUtils.map(proxies.proxies, proxy -> {
+                    String password = security.decrypt(proxy.getPassword(), decryptedMasterPassword);
+                    return password == null ? proxy : proxy.withPassword(password);
+                });
+            }
         }
     }
 
@@ -192,7 +208,8 @@ public MavenSettings merge(@Nullable MavenSettings installSettings) {
                 profiles == null ? installSettings.profiles : profiles.merge(installSettings.profiles),
                 activeProfiles == null ? installSettings.activeProfiles : activeProfiles.merge(installSettings.activeProfiles),
                 mirrors == null ? installSettings.mirrors : mirrors.merge(installSettings.mirrors),
-                servers == null ? installSettings.servers : servers.merge(installSettings.servers)
+                servers == null ? installSettings.servers : servers.merge(installSettings.servers),
+                proxies == null ? installSettings.proxies : proxies.merge(installSettings.proxies)
         );
     }
 
@@ -254,7 +271,8 @@ public MavenSettings interpolate(MavenSettings mavenSettings) {
                     mavenSettings.profiles,
                     interpolate(mavenSettings.activeProfiles),
                     interpolate(mavenSettings.mirrors),
-                    interpolate(mavenSettings.servers));
+                    interpolate(mavenSettings.servers),
+                    interpolate(mavenSettings.proxies));
         }
 
         private @Nullable ActiveProfiles interpolate(@Nullable ActiveProfiles activeProfiles) {
@@ -295,6 +313,17 @@ private Server interpolate(Server server) {
                     interpolate(server.configuration));
         }
 
+        private @Nullable Proxies interpolate(@Nullable Proxies proxies) {
+            if (proxies == null) return null;
+            return new Proxies(ListUtils.map(proxies.getProxies(), this::interpolate));
+        }
+
+        private Proxy interpolate(Proxy proxy) {
+            return new Proxy(interpolate(proxy.id), proxy.active, interpolate(proxy.protocol),
+                    interpolate(proxy.host), proxy.port, interpolate(proxy.username),
+                    interpolate(proxy.password), interpolate(proxy.nonProxyHosts));
+        }
+
         private @Nullable String interpolate(@Nullable String s) {
             return s == null ? null : propertyPlaceholders.replacePlaceholders(s, propertyResolver);
         }
@@ -446,6 +475,64 @@ public static class Server {
         ServerConfiguration configuration;
     }
 
+    @FieldDefaults(level = AccessLevel.PRIVATE)
+    @Getter
+    @Setter
+    @AllArgsConstructor
+    @NoArgsConstructor
+    public static class Proxies {
+        @JacksonXmlProperty(localName = "proxy")
+        @JacksonXmlElementWrapper(useWrapping = false)
+        List<Proxy> proxies = emptyList();
+
+        public Proxies merge(@Nullable Proxies proxies) {
+            final Map<String, Proxy> merged = new LinkedHashMap<>();
+            int nullIndex = 0;
+            for (Proxy proxy : this.proxies) {
+                String key = proxy.id != null ? proxy.id : "__null_" + nullIndex++;
+                merged.put(key, proxy);
+            }
+            if (proxies != null) {
+                for (Proxy proxy : proxies.getProxies()) {
+                    if (proxy.getId() != null) {
+                        merged.putIfAbsent(proxy.getId(), proxy);
+                    } else {
+                        merged.put("__null_" + nullIndex++, proxy);
+                    }
+                }
+            }
+            return new Proxies(new ArrayList<>(merged.values()));
+        }
+    }
+
+    @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+    @Data
+    @With
+    public static class Proxy {
+        @Nullable
+        String id;
+
+        @Nullable
+        Boolean active;
+
+        @Nullable
+        String protocol;
+
+        String host;
+
+        @Nullable
+        Integer port;
+
+        @Nullable
+        String username;
+
+        @Nullable
+        String password;
+
+        @Nullable
+        String nonProxyHosts;
+    }
+
     @EqualsAndHashCode
     @FieldDefaults(level = AccessLevel.PRIVATE)
     @ToString

rewrite-maven/src/test/java/org/openrewrite/maven/MavenSettingsTest.java

@@ -1011,4 +1011,41 @@ private void createSettingsSecurityFile() throws IOException {
             </settingsSecurity>
             """.formatted(MASTER_PASS_ENCRYPTED));
     }
+
+    @Test
+    @Issue("https://github.com/openrewrite/rewrite-maven-plugin/issues/543")
+    void parseProxies() {
+        MavenSettings settings = MavenSettings.parse(Parser.Input.fromString(Path.of("settings.xml"),
+          //language=xml
+          """
+            <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0">
+                <proxies>
+                    <proxy>
+                        <id>my-proxy</id>
+                        <active>true</active>
+                        <protocol>https</protocol>
+                        <host>proxy.example.com</host>
+                        <port>8080</port>
+                        <username>proxyuser</username>
+                        <password>proxypass</password>
+                        <nonProxyHosts>localhost|*.example.com</nonProxyHosts>
+                    </proxy>
+                </proxies>
+            </settings>
+            """), ctx);
+
+        assertThat(settings).isNotNull();
+        assertThat(settings.getProxies()).isNotNull();
+        assertThat(settings.getProxies().getProxies()).hasSize(1);
+
+        MavenSettings.Proxy proxy = settings.getProxies().getProxies().get(0);
+        assertThat(proxy.getId()).isEqualTo("my-proxy");
+        assertThat(proxy.getActive()).isTrue();
+        assertThat(proxy.getProtocol()).isEqualTo("https");
+        assertThat(proxy.getHost()).isEqualTo("proxy.example.com");
+        assertThat(proxy.getPort()).isEqualTo(8080);
+        assertThat(proxy.getUsername()).isEqualTo("proxyuser");
+        assertThat(proxy.getPassword()).isEqualTo("proxypass");
+        assertThat(proxy.getNonProxyHosts()).isEqualTo("localhost|*.example.com");
+    }
 }