refactor: Collapse the duplicated gzip decision in the renderer

All three render paths repeated the same guard — already coded, not
compressible, or a status that carries no content — then announced Vary,
then checked threshold and Accept-Encoding. That is now one
shouldCompress method the three paths share, with a negative length
meaning "unknown, treat as over the threshold" so streams keep their
semantics.

Also drops the single-argument ResponseRenderer constructor, which no
longer had a caller in main, and trims incidental weight in the header
parsers: the boxed tri-state in AcceptEncodingHeader becomes two plain
booleans, the compressible-suffix Set becomes three endsWith calls, and
single-use string constants are inlined to match ContentTypeHeader.

530 to 498 lines across the five files; behaviour unchanged.

Author: thced

src/main/java/com/retailsvc/http/internal/AcceptEncodingHeader.java

@@ -5,10 +5,6 @@
 /** Parses {@code Accept-Encoding} request header values (RFC 9110 §12.5.3). */
 public final class AcceptEncodingHeader {
 
-  private static final String GZIP = "gzip";
-  private static final String X_GZIP = "x-gzip";
-  private static final String WILDCARD = "*";
-  private static final String QUALITY = "q";
   private static final double DEFAULT_QUALITY = 1.0;
 
   private AcceptEncodingHeader() {}
@@ -22,8 +18,9 @@ public static boolean acceptsGzip(String header) {
     if (header == null) {
       return false;
     }
-    Boolean gzipAccepted = null;
-    Boolean wildcardAccepted = null;
+    boolean gzipSeen = false;
+    boolean gzipAccepted = false;
+    boolean wildcardAccepted = false;
     for (String token : header.split(",")) {
       String trimmed = token.trim();
       if (trimmed.isEmpty()) {
@@ -33,16 +30,14 @@ public static boolean acceptsGzip(String header) {
       String coding =
           (semi < 0 ? trimmed : trimmed.substring(0, semi)).trim().toLowerCase(Locale.ROOT);
       boolean accepted = quality(semi < 0 ? null : trimmed.substring(semi + 1)) > 0;
-      if (GZIP.equals(coding) || X_GZIP.equals(coding)) {
-        gzipAccepted = gzipAccepted == null ? accepted : gzipAccepted || accepted;
-      } else if (WILDCARD.equals(coding)) {
-        wildcardAccepted = wildcardAccepted == null ? accepted : wildcardAccepted || accepted;
+      if ("gzip".equals(coding) || "x-gzip".equals(coding)) {
+        gzipSeen = true;
+        gzipAccepted |= accepted;
+      } else if ("*".equals(coding)) {
+        wildcardAccepted |= accepted;
       }
     }
-    if (gzipAccepted != null) {
-      return gzipAccepted;
-    }
-    return wildcardAccepted != null && wildcardAccepted;
+    return gzipSeen ? gzipAccepted : wildcardAccepted;
   }
 
   /**
@@ -60,7 +55,7 @@ private static double quality(String parameters) {
         continue;
       }
       String name = trimmed.substring(0, equals).trim().toLowerCase(Locale.ROOT);
-      if (QUALITY.equals(name)) {
+      if ("q".equals(name)) {
         try {
           return Double.parseDouble(trimmed.substring(equals + 1).trim());
         } catch (NumberFormatException e) {

src/main/java/com/retailsvc/http/internal/ContentEncodingHeader.java

@@ -5,19 +5,15 @@
 /** Classifies a request {@code Content-Encoding} into the codings the server can decode. */
 public final class ContentEncodingHeader {
 
-  private static final String IDENTITY_CODING = "identity";
-  private static final String GZIP_CODING = "gzip";
-  private static final String X_GZIP_CODING = "x-gzip";
-
   private ContentEncodingHeader() {}
 
-  /** The content coding applied to a request body. */
+  /**
+   * The coding applied to a request body: none (absent or the {@code identity} no-op), a single
+   * gzip, or one this server cannot decode and the caller renders 415 for.
+   */
   public enum Coding {
-    /** No coding, or the explicit {@code identity} no-op. */
     NONE,
-    /** A single gzip coding. */
     GZIP,
-    /** A coding this server cannot decode; the caller renders 415. */
     UNSUPPORTED
   }
 
@@ -33,13 +29,13 @@ public static Coding parse(String header) {
     Coding result = Coding.NONE;
     for (String token : header.split(",")) {
       String coding = token.trim().toLowerCase(Locale.ROOT);
-      if (coding.isEmpty() || IDENTITY_CODING.equals(coding)) {
+      if (coding.isEmpty() || "identity".equals(coding)) {
         continue;
       }
       if (result != Coding.NONE) {
         return Coding.UNSUPPORTED;
       }
-      if (GZIP_CODING.equals(coding) || X_GZIP_CODING.equals(coding)) {
+      if ("gzip".equals(coding) || "x-gzip".equals(coding)) {
         result = Coding.GZIP;
       } else {
         return Coding.UNSUPPORTED;

src/main/java/com/retailsvc/http/internal/ResponseCompression.java

@@ -21,8 +21,6 @@ public final class ResponseCompression {
           "application/javascript",
           "application/x-ndjson");
 
-  private static final Set<String> COMPRESSIBLE_SUFFIXES = Set.of("+json", "+xml", "+yaml");
-
   private ResponseCompression() {}
 
   /**
@@ -41,10 +39,8 @@ public static boolean isCompressible(String contentType) {
     if (mediaType.startsWith(TEXT_PREFIX)) {
       return !EVENT_STREAM.equals(mediaType);
     }
-    for (String suffix : COMPRESSIBLE_SUFFIXES) {
-      if (mediaType.endsWith(suffix)) {
-        return true;
-      }
+    if (mediaType.endsWith("+json") || mediaType.endsWith("+xml") || mediaType.endsWith("+yaml")) {
+      return true;
     }
     return COMPRESSIBLE_TYPES.contains(mediaType);
   }

src/main/java/com/retailsvc/http/internal/ResponseRenderer.java

@@ -35,10 +35,6 @@ public final class ResponseRenderer {
   private final Map<String, TypeMapper> mappers;
   private final long minimumGzipBytes;
 
-  public ResponseRenderer(Map<String, TypeMapper> mappers) {
-    this(mappers, DEFAULT_MINIMUM_GZIP_BYTES);
-  }
-
   public ResponseRenderer(Map<String, TypeMapper> mappers, long minimumGzipBytes) {
     this.mappers = Map.copyOf(mappers);
     this.minimumGzipBytes = minimumGzipBytes;
@@ -72,15 +68,11 @@ private void renderEmpty(HttpExchange exchange, Headers headers, int status, Str
     if (contentType != null && !headers.containsKey(CONTENT_TYPE)) {
       headers.add(CONTENT_TYPE, contentType);
     }
-    if (!headers.containsKey(CONTENT_ENCODING)
-        && ResponseCompression.isCompressible(contentType)
-        && bodyAllowed(status)) {
-      addVary(headers);
-      if (declaredLength(headers) >= minimumGzipBytes && acceptsGzip(exchange)) {
-        headers.remove(CONTENT_LENGTH);
-      }
+    long declared = declaredLength(headers);
+    if (shouldCompress(exchange, headers, status, contentType, declared) && declared >= 0) {
+      headers.remove(CONTENT_LENGTH);
     }
-    exchange.sendResponseHeaders(status, -1);
+    exchange.sendResponseHeaders(status, UNKNOWN_LENGTH);
   }
 
   private void renderStream(
@@ -90,7 +82,7 @@ private void renderStream(
       headers.add(CONTENT_TYPE, contentType);
     }
     long declared = writer instanceof BodyWriter.Sized sized ? sized.length() : UNKNOWN_LENGTH;
-    if (compressStream(exchange, headers, status, contentType, declared)) {
+    if (shouldCompress(exchange, headers, status, contentType, declared)) {
       headers.set(CONTENT_ENCODING, GZIP);
       exchange.sendResponseHeaders(status, CHUNKED);
       try (OutputStream out = ResponseCompression.gzipStream(exchange.getResponseBody())) {
@@ -105,20 +97,19 @@ private void renderStream(
   }
 
   /**
-   * A coded stream has to go out chunked, because the length a {@code Sized} body declares measures
-   * the uncoded form. A body of unknown length is compressed regardless of the threshold —
-   * buffering it to find out how big it is would defeat streaming it.
+   * Whether a body of {@code length} bytes should be gzipped, marking the response as varying by
+   * {@code Accept-Encoding} whenever it could have been. A negative length means unknown, which
+   * counts as over the threshold: measuring a stream to find out would defeat streaming it.
    */
-  private boolean compressStream(
-      HttpExchange exchange, Headers headers, int status, String contentType, long declaredLength) {
+  private boolean shouldCompress(
+      HttpExchange exchange, Headers headers, int status, String contentType, long length) {
     if (headers.containsKey(CONTENT_ENCODING)
         || !ResponseCompression.isCompressible(contentType)
         || !bodyAllowed(status)) {
       return false;
     }
     addVary(headers);
-    boolean worthCoding = declaredLength < 0 || declaredLength >= minimumGzipBytes;
-    return worthCoding && acceptsGzip(exchange);
+    return (length < 0 || length >= minimumGzipBytes) && acceptsGzip(exchange);
   }
 
   /** The length a handler declared for a body it did not write, or -1 when absent or unreadable. */
@@ -158,21 +149,11 @@ private void renderBytes(
     }
   }
 
-  /**
-   * Gzips the body when the client asked for it and the payload is big enough to be worth it. A
-   * handler that coded the body itself is left alone, and so is a payload that gzip fails to
-   * shrink.
-   */
+  /** Gzips the body when it is worth it, leaving a payload gzip fails to shrink uncoded. */
   private byte[] maybeCompress(
       HttpExchange exchange, Headers headers, int status, String contentType, byte[] bytes)
       throws IOException {
-    if (headers.containsKey(CONTENT_ENCODING)
-        || !ResponseCompression.isCompressible(contentType)
-        || !bodyAllowed(status)) {
-      return bytes;
-    }
-    addVary(headers);
-    if (bytes.length < minimumGzipBytes || !acceptsGzip(exchange)) {
+    if (!shouldCompress(exchange, headers, status, contentType, bytes.length)) {
       return bytes;
     }
     byte[] gzipped = ResponseCompression.gzip(bytes);

src/test/java/com/retailsvc/http/internal/DispatchHandlerTest.java

@@ -1,5 +1,6 @@
 package com.retailsvc.http.internal;
 
+import static com.retailsvc.http.internal.ResponseRenderer.DEFAULT_MINIMUM_GZIP_BYTES;
 import static java.net.HttpURLConnection.HTTP_INTERNAL_ERROR;
 import static java.net.HttpURLConnection.HTTP_OK;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -44,14 +45,19 @@ private static HttpExchange stubExchange() {
   }
 
   private static DispatchHandler dispatcher(Map<String, RequestHandler> handlers) {
-    return new DispatchHandler(handlers, List.of(), List.of(), new ResponseRenderer(Map.of()));
+    return new DispatchHandler(
+        handlers, List.of(), List.of(), new ResponseRenderer(Map.of(), DEFAULT_MINIMUM_GZIP_BYTES));
   }
 
   private static DispatchHandler dispatcher(
       Map<String, RequestHandler> handlers,
       List<RequestInterceptor> interceptors,
       List<ResponseDecorator> decorators) {
-    return new DispatchHandler(handlers, interceptors, decorators, new ResponseRenderer(Map.of()));
+    return new DispatchHandler(
+        handlers,
+        interceptors,
+        decorators,
+        new ResponseRenderer(Map.of(), DEFAULT_MINIMUM_GZIP_BYTES));
   }
 
   private static void withRequest(String operationId, ScopedValue.CallableOp<Void, Exception> body)

src/test/java/com/retailsvc/http/internal/ExtrasRouterTest.java

@@ -1,5 +1,6 @@
 package com.retailsvc.http.internal;
 
+import static com.retailsvc.http.internal.ResponseRenderer.DEFAULT_MINIMUM_GZIP_BYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
@@ -145,7 +146,7 @@ private static ExtrasRouter newRouter(Map<String, RequestHandler> extras) {
     Map<String, TypeMapper> mappers = Map.of("application/json", new GsonTypeMapper());
     return new ExtrasRouter(
         extras,
-        new ResponseRenderer(mappers),
+        new ResponseRenderer(mappers, DEFAULT_MINIMUM_GZIP_BYTES),
         new RequestBodyReader(RequestBodyReader.DEFAULT_MAX_DECOMPRESSED_BYTES));
   }
 

src/test/java/com/retailsvc/http/internal/RequestPreparationFilterTest.java

@@ -1,5 +1,6 @@
 package com.retailsvc.http.internal;
 
+import static com.retailsvc.http.internal.ResponseRenderer.DEFAULT_MINIMUM_GZIP_BYTES;
 import static java.net.HttpURLConnection.HTTP_UNSUPPORTED_TYPE;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -114,7 +115,7 @@ public byte[] writeTo(Object value) {
         new DefaultValidator(spec::resolveSchema),
         mappers,
         rethrow,
-        new ResponseRenderer(mappers),
+        new ResponseRenderer(mappers, DEFAULT_MINIMUM_GZIP_BYTES),
         List.of(),
         new RequestBodyReader(RequestBodyReader.DEFAULT_MAX_DECOMPRESSED_BYTES));
   }