Use Map for header in Expression Languages (#2386)

* refactor: replace return-Exchange style of HttpClient.call with updated void-return approach and simplify response handling across multiple classes and tests

* refactor: introduce `HeaderMap` to unify header handling, adjust related tests and update SpEL/Groovy behavior

* refactor: introduce `HeaderMap` to unify header handling, adjust related tests and update SpEL/Groovy behavior

* refactor: replace deprecated header handling methods with updated APIs in examples, templates, and tests

* refactor: add @NotNull annotations and remove unnecessary `throws` declarations in HeaderMap and related tests

* refactor: fix header handling inconsistencies, update examples and tests, and simplify stream operations

* refactor: remove `SpELHeader` and `SpELHeaderToStringTypeConverter`, update header handling to use `HeaderMap`, and adjust related examples and tests

* refactor: simplify header initialization in tests, enhance type safety in SpELMap, and optimize import usage across classes

* refactor: enhance header handling consistency, improve case-insensitivity in tests, and update `splitByComma` for empty input handling

* refactor: simplify `getMethodSetter` usage in `MethodSetterTest` and clean up Javadoc in `StringUtil`

* refactor: streamline header case-insensitivity handling, simplify `getUniqueHeaderNames`, and improve related tests

* refactor: remove camelCase-to-kebab-case conversion logic, update header handling and related tests, and simplify file replacement operations in examples

* refactor: remove camelCase-to-kebab-case conversion logic, update header handling and related tests, and simplify file replacement operations in examples

* refactor: simplify header access logic in `SpELExchangeEvaluationContextTest`, remove unused import in `SpELCookie`

Author: predic8

annot/src/test/java/com/predic8/membrane/annot/util/GrammarMock.java

@@ -1,15 +1,28 @@
+/* Copyright 2025 predic8 GmbH, www.predic8.com
+
+   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. */
+
 package com.predic8.membrane.annot.util;
 
 import com.predic8.membrane.annot.Grammar;
 
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
 
 import static java.util.List.of;
 
 public class GrammarMock implements Grammar {
 
-    private HashMap<String, Class<?>> elements = new HashMap<>();
+    private final Map<String, Class<?>> elements = new HashMap<>();
 
     @Override
     public Class<?> getElement(String key) {

annot/src/test/java/com/predic8/membrane/annot/yaml/MethodSetterTest.java

@@ -1,21 +1,38 @@
+/* Copyright 2025 predic8 GmbH, www.predic8.com
+
+   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. */
+
 package com.predic8.membrane.annot.yaml;
 
 import com.predic8.membrane.annot.MCChildElement;
 import com.predic8.membrane.annot.util.GrammarMock;
 import org.junit.jupiter.api.Test;
 
+import static com.predic8.membrane.annot.yaml.MethodSetter.getMethodSetter;
 import static org.junit.jupiter.api.Assertions.*;
 
 class MethodSetterTest {
 
-    public class A {
+    @SuppressWarnings("unused")
+    static class A {
         public void setA1(B b) {}
         public void setA2(B b) {}
         @MCChildElement
         public void setA3(B b) {}
     }
 
-    public class A2 {
+    @SuppressWarnings("unused")
+    static class A2 {
         @MCChildElement
         public void setA1(B b) {}
         @MCChildElement
@@ -28,28 +45,24 @@ public static class C {}
 
     @Test
     public void dontUseMethodsWithoutChildElementAnnotation() {
-        MethodSetter ms = MethodSetter.getMethodSetter(new ParsingContext("foo", null,
+        MethodSetter ms = getMethodSetter(new ParsingContext("foo", null,
                         new GrammarMock().withGlobalElement("b", B.class)),
                 A.class, "b");
         assertEquals("setA3", ms.getSetter().getName());
     }
 
     @Test
     public void multiplePotentialSettersFound() {
-        assertThrowsExactly(RuntimeException.class, () -> {
-            MethodSetter.getMethodSetter(new ParsingContext("foo", null,
-                            new GrammarMock().withGlobalElement("b", B.class)),
-                    A2.class, "b");
-        });
+        assertThrowsExactly(RuntimeException.class, () -> getMethodSetter(new ParsingContext("foo", null,
+                        new GrammarMock().withGlobalElement("b", B.class)),
+                A2.class, "b"));
     }
 
     @Test
     public void noPotentialSetterFound() {
-        assertThrowsExactly(RuntimeException.class, () -> {
-            MethodSetter.getMethodSetter(new ParsingContext("foo", null,
-                            new GrammarMock().withGlobalElement("c", C.class)),
-                    A2.class, "c");
-        });
+        assertThrowsExactly(RuntimeException.class, () -> getMethodSetter(new ParsingContext("foo", null,
+                        new GrammarMock().withGlobalElement("c", C.class)),
+                A2.class, "c"));
     }
 
 }

core/src/main/java/com/predic8/membrane/core/http/Header.java

@@ -18,22 +18,24 @@
 import com.predic8.membrane.core.http.cookie.*;
 import com.predic8.membrane.core.util.*;
 import jakarta.mail.internet.*;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.*;
 import org.slf4j.*;
 
 import java.io.*;
 import java.security.*;
 import java.util.*;
-import java.util.function.Predicate;
+import java.util.ArrayList;
+import java.util.function.*;
 import java.util.regex.*;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+import java.util.stream.*;
 
 import static com.predic8.membrane.core.http.MimeType.*;
-import static com.predic8.membrane.core.util.HttpUtil.readLine;
+import static com.predic8.membrane.core.util.HttpUtil.*;
 import static java.nio.charset.StandardCharsets.*;
-import static java.util.Arrays.stream;
+import static java.util.Arrays.*;
+import static java.util.Collections.*;
 import static java.util.regex.Pattern.*;
+import static java.util.stream.Collectors.*;
 import static org.apache.commons.codec.binary.Base64.*;
 
 /**
@@ -113,7 +115,7 @@ public class Header {
 	private static final Pattern timeoutPattern = compile("timeout\\s*=\\s*(\\d+)", CASE_INSENSITIVE);
 	private static final Pattern maxPattern = compile("max\\s*=\\s*(\\d+)", CASE_INSENSITIVE);
 
-	private final ArrayList<HeaderField> fields = new ArrayList<>();
+	private final List<HeaderField> fields = new ArrayList<>();
 
 	public Header() {
 	}
@@ -189,10 +191,7 @@ public void remove(HeaderField field) {
 	}
 
 	public void removeFields(String name) {
-		List<HeaderField> deleteValues = fields.stream()
-				.filter(f -> f.getHeaderName().hasName(name))
-				.toList();
-		fields.removeAll(deleteValues);
+        fields.removeAll(filterByHeaderName(name).toList());
 	}
 
 	/**
@@ -207,7 +206,17 @@ public List<HeaderField> getValues(HeaderName headerName) {
 				.toList();
 	}
 
-	/**
+    public String getValuesAsString(String name) {
+        var list = filterByHeaderName(name).map(HeaderField::getValue).toList();
+        if (list.isEmpty()) return null;
+        return String.join(", ", list);
+    }
+
+    private @NotNull Stream<HeaderField> filterByHeaderName(String name) {
+        return fields.stream().filter(hf -> hf.getHeaderName().hasName(name));
+    }
+
+    /**
 	 * Retrieves the first header value corresponding to the specified header name.
 	 *
 	 * Iterates through the header fields and returns the value of the first field that matches the given name.
@@ -217,8 +226,7 @@ public List<HeaderField> getValues(HeaderName headerName) {
 	 * @return the value of the matching header field, or {@code null} if not present
 	 */
 	public String getFirstValue(String name) {
-		return fields.stream()
-				.filter(field -> field.getHeaderName().hasName(name))
+		return filterByHeaderName(name)
 				.findFirst()
 				.map(HeaderField::getValue)
 				.orElse(null);
@@ -233,8 +241,7 @@ public HeaderField[] getAllHeaderFields() {
 	}
 
 	public boolean contains(String header) {
-		return fields.stream()
-				.anyMatch(headerField -> headerField.getHeaderName().hasName(header));
+        return filterByHeaderName(header).findAny().isPresent();
 	}
 
 	public boolean contains(HeaderName header) {
@@ -248,7 +255,7 @@ public boolean contains(HeaderName header) {
 	public void write(OutputStream out) throws IOException {
 		byte[] bytes = fields.stream()
 				.map(f -> "%s: %s%s".formatted(f.getHeaderName(), f.getValue(), Constants.CRLF))
-				.collect(Collectors.joining()).getBytes(ISO_8859_1);
+				.collect(joining()).getBytes(ISO_8859_1);
 		out.write(bytes);
 	}
 
@@ -386,7 +393,7 @@ public boolean is100ContinueExpected() {
 	public String toString() {
 		return fields.stream()
 				.map(HeaderField::toString)
-				.collect(Collectors.joining());
+				.collect(joining());
 	}
 
 	/**
@@ -466,9 +473,7 @@ public int estimateHeapSize() {
 	}
 
 	public int getNumberOf(String headerName) {
-		return (int) fields.stream()
-				.filter(f -> f.getHeaderName().hasName(headerName))
-				.count();
+		return (int) filterByHeaderName(headerName).count();
 	}
 
 	/**
@@ -514,10 +519,9 @@ public String getWwwAuthenticate(){
 	}
 
 	public String getNormalizedValue(String headerName) {
-		var s = fields.stream()
-				.filter(f -> f.getHeaderName().hasName(headerName))
+		var s = filterByHeaderName(headerName)
 				.map(HeaderField::getValue)
-				.collect(Collectors.joining(","));
+				.collect(joining(","));
 		return s.isEmpty() ? null : s;
 	}
 
@@ -601,4 +605,34 @@ public String getUpgradeProtocol() {
 		return getFirstValue(UPGRADE);
 	}
 
+    public int size() {
+        return fields.size();
+    }
+
+    public boolean isEmpty() {
+        return fields.isEmpty();
+    }
+
+    /**
+     * Retrieves an unmodifiable list of header fields contained in this header.
+     * The state of this class should not be modified directly.
+     *
+     * @return an unmodifiable list of HeaderField objects representing the header fields
+     */
+    public List<HeaderField> getFields() {
+        return unmodifiableList(fields);
+    }
+
+    /**
+     * Returns a set of all unique header field names present in this header.
+     * The order of names in the set is not guaranteed.
+     *
+     * @return a set containing the unique header field names
+     */
+    public Set<String> getUniqueHeaderNames() {
+        // First Set to use the equals method of HeaderField to get unique header names even if they differ in case.
+        // Then the HeaderNames are turned into Strings
+        return fields.stream().map(HeaderField::getHeaderName)
+                .collect(toSet()).stream().map(HeaderName::getName).collect(toSet());
+    }
 }