This class never writes to disk and never logs the resolved contents.
+ */ +public class KeeperConfig { + + private static final Logger LOGGER = Logger.getLogger(KeeperConfig.class.getName()); + + /** Filename extensions tried during named lookup. */ + private static final ListSelectable per-request, falls back to a service-wide default. The correct + * answer depends on the deployment:
+ * + *The {@code is*} methods are pure predicates. {@code trimToNull} is the + * one that produces a cleaned value.
+ */ +public final class Checks { + + private Checks() {} + + /** + * Validates a string as standard base64, surrounding whitespace is + * tolerated. + * + * @param s The string to check. + * @return {@code true} if {@code s} decodes cleanly as base64. + */ + public static boolean isBase64(String s) { + if (s == null) { + return false; + } + + String t = s.trim(); + + if (t.isEmpty()) { + return false; + } + + try { + Base64.getDecoder().decode(t); + return true; + } catch (IllegalArgumentException e) { + return false; + } + } + + /** + * Validates a string as parseable JSON. Defers entirely to Jackson. + * Accepts any well-formed JSON value (object, array, scalar, etc.). + * + * @param s The string to check. + * @return {@code true} if {@code s} is well-formed JSON. + */ + public static boolean isJson(String s) { + if (s == null) { + return false; + } + + try { + JsonNode node = JsonHandler.getObjectMapper().readTree(s); + return node != null && !node.isMissingNode(); + } catch (IOException e) { + return false; + } + } + + /** + * Whitespace-tolerant emptiness check. "Missing", "empty", and + * "whitespace-only" all collapse to {@code true}. + * + * @param s The string to check. + * @return {@code true} if {@code s} is {@code null}, zero-length, or + * whitespace only. + */ + public static boolean isNullOrBlank(String s) { + return s == null || s.isBlank(); + } + + /** + * Null-tolerant emptiness check for any {@link Collection}. Saves the + * {@code c == null || c.isEmpty()} pair from being inlined at every + * call site that handles an optional list, set, or map values view. + * + * @param c The collection to check; may be {@code null}. + * @return {@code true} if {@code c} is {@code null} or has zero elements. + */ + public static boolean isNullOrEmpty(Collection c) { + return c == null || c.isEmpty(); + } + + /** + * Normalizes raw input into one of two states: {@code null} (for + * missing/empty/whitespace) or the trimmed value. Downstream code only + * has to null-check rather than worry about empty strings or stray + * whitespace. + * + *{@link #isNullOrBlank} can't replace this: it only tells you whether + * the string is missing; it doesn't give you back the cleaned value.
+ * + * @param s The string to normalize. + * @return The trimmed value, or {@code null} if the input was null, empty, + * or whitespace only. + */ + public static String trimToNull(String s) { + if (s == null) { + return null; + } + + String t = s.trim(); + + return t.isEmpty() ? null : t; + } +} diff --git a/src/main/java/com/byteskeptical/credcat/util/JsonHandler.java b/src/main/java/com/byteskeptical/credcat/util/JsonHandler.java index 891e454..7a627d3 100644 --- a/src/main/java/com/byteskeptical/credcat/util/JsonHandler.java +++ b/src/main/java/com/byteskeptical/credcat/util/JsonHandler.java @@ -1,35 +1,91 @@ package com.byteskeptical.credcat.util; - + +import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializationFeature; +import java.io.IOException; +import java.io.OutputStream; +import java.util.Map; /** * The (Serial) Transporter aka JSON Statham. */ public class JsonHandler { - private static final ObjectMapper objectMapper = new ObjectMapper(); + + private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper() + .setSerializationInclusion(JsonInclude.Include.NON_NULL) + .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false) + .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + + /** No instance, no problem. */ + private JsonHandler() {} /** - * Converts a Java object to a pretty-printed JSON string. + * Exposes the shared, pre-configured ObjectMapper for callers that need + * Jackson's streaming or tree APIs directly. * - * @param obj The object to serialize to JSON. - * @return The JSON string representation of the object. - * @throws JsonProcessingException if the object cannot be processed as JSON. + * @return The shared, thread-safe ObjectMapper instance. + */ + public static ObjectMapper getObjectMapper() { + return OBJECT_MAPPER; + } + + /** + * Serializes an object to pretty-printed JSON. + * + * @param obj The object to serialize. + * @return The JSON string representation. + * @throws JsonProcessingException if {@code obj} cannot be processed as JSON. */ public static String toJson(Object obj) throws JsonProcessingException { - return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj); + return OBJECT_MAPPER.writerWithDefaultPrettyPrinter() + .writeValueAsString(obj); + } + + /** + * Streams an object as JSON straight to an output stream, sidestepping + * the intermediate String allocation that {@link #toJson(Object)} requires. + * + * @param obj The object to serialize. + * @param out The destination stream. Not closed by this method. + * @throws IOException if writing fails. + */ + public static void writeJson(Object obj, OutputStream out) throws IOException { + OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValue(out, obj); + } + + /** + * Builds a single-key JSON object as a string. For small status envelopes + * (errors, version banners, etc.) where the caller would rather not deal + * with a checked exception for input that's trivially serializable. + * + * @param key The JSON property name. Must not be {@code null}. + * @param value The value. {@code null} is rendered as an empty string so + * the output is always valid, parseable JSON. + * @return A JSON object like {@code {"key" : "value"}}. + */ + public static String envelope(String key, String value) { + try { + return toJson(Map.of(key, value != null ? value : "")); + } catch (JsonProcessingException e) { + // A two-string Map can't actually fail. Fall back to a parseable + // empty object if it somehow does. + return "{}"; + } } /** * Deserializes a JSON string into a Java object of a specified class. * - * @paramStubs are lenient: every mock is built up front but each test + * invocation exercises only one, so strict stubbing would flag the rest.
*/ private static StreamStubs are lenient: every mock is built up front but each test
@@ -180,7 +180,7 @@ private static Stream