Reintroduce Unit to only have valid units in the enum

Author: simonbasle

Diff for: spring-context/src/main/java/org/springframework/format/annotation/DurationFormat.java

@@ -23,6 +23,9 @@
 import java.lang.annotation.Target;
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
+import java.util.function.Function;
+
+import org.springframework.lang.Nullable;
 
 /**
  * Declares that a field or method parameter should be formatted as a {@link java.time.Duration},
@@ -43,11 +46,11 @@
 	Style style() default Style.ISO8601;
 
 	/**
-	 * Define which {@code ChronoUnit} to fall back to in case the {@code style()}
+	 * Define which {@link Unit} to fall back to in case the {@code style()}
 	 * needs a unit for either parsing or printing, and none is explicitly provided in
-	 * the input.
+	 * the input ({@code Unit.MILLIS} if unspecified).
 	 */
-	ChronoUnit defaultUnit() default ChronoUnit.MILLIS;
+	Unit defaultUnit() default Unit.MILLIS;
 
 	/**
 	 * Duration format styles.
@@ -74,4 +77,100 @@ enum Style {
 		ISO8601;
 	}
 
+	/**
+	 * Duration format unit, which mirrors a subset of {@link ChronoUnit} and allows conversion to and from
+	 * supported {@code ChronoUnit} as well as converting durations to longs.
+	 * The enum includes its corresponding suffix in the {@link Style#SIMPLE simple} Duration format style.
+	 */
+	enum Unit {
+		/**
+		 * Nanoseconds ({@code "ns"}).
+		 */
+		NANOS(ChronoUnit.NANOS, "ns", Duration::toNanos),
+
+		/**
+		 * Microseconds ({@code "us"}).
+		 */
+		MICROS(ChronoUnit.MICROS, "us", duration -> duration.toNanos() / 1000L),
+
+		/**
+		 * Milliseconds ({@code "ms"}).
+		 */
+		MILLIS(ChronoUnit.MILLIS, "ms", Duration::toMillis),
+
+		/**
+		 * Seconds ({@code "s"}).
+		 */
+		SECONDS(ChronoUnit.SECONDS, "s", Duration::getSeconds),
+
+		/**
+		 * Minutes ({@code "m"}).
+		 */
+		MINUTES(ChronoUnit.MINUTES, "m", Duration::toMinutes),
+
+		/**
+		 * Hours ({@code "h"}).
+		 */
+		HOURS(ChronoUnit.HOURS, "h", Duration::toHours),
+
+		/**
+		 * Days ({@code "d"}).
+		 */
+		DAYS(ChronoUnit.DAYS, "d", Duration::toDays);
+
+		private final ChronoUnit chronoUnit;
+
+		private final String suffix;
+
+		private final Function<Duration, Long> longValue;
+
+		Unit(ChronoUnit chronoUnit, String suffix, Function<Duration, Long> toUnit) {
+			this.chronoUnit = chronoUnit;
+			this.suffix = suffix;
+			this.longValue = toUnit;
+		}
+
+		public ChronoUnit asChronoUnit() {
+			return this.chronoUnit;
+		}
+
+		public String asSuffix() {
+			return this.suffix;
+		}
+
+		public Duration parse(String value) {
+			return Duration.of(Long.parseLong(value), asChronoUnit());
+		}
+
+		public String print(Duration value) {
+			return longValue(value) + asSuffix();
+		}
+
+		public long longValue(Duration value) {
+			return this.longValue.apply(value);
+		}
+
+		public static Unit fromChronoUnit(@Nullable ChronoUnit chronoUnit) {
+			if (chronoUnit == null) {
+				return Unit.MILLIS;
+			}
+			for (Unit candidate : values()) {
+				if (candidate.chronoUnit == chronoUnit) {
+					return candidate;
+				}
+			}
+			throw new IllegalArgumentException("No matching Unit for ChronoUnit." + chronoUnit.name());
+		}
+
+		public static Unit fromSuffix(String suffix) {
+			for (Unit candidate : values()) {
+				if (candidate.suffix.equalsIgnoreCase(suffix)) {
+					return candidate;
+				}
+			}
+			throw new IllegalArgumentException("'" + suffix + "' is not a valid simple duration Unit");
+		}
+
+	}
+
 }

Diff for: spring-context/src/main/java/org/springframework/format/datetime/standard/DurationFormatter.java

@@ -18,7 +18,6 @@
 
 import java.text.ParseException;
 import java.time.Duration;
-import java.time.temporal.ChronoUnit;
 import java.util.Locale;
 
 import org.springframework.format.Formatter;
@@ -39,7 +38,7 @@ class DurationFormatter implements Formatter<Duration> { //TODO why is this one
 
 	private final DurationFormat.Style style;
 	@Nullable
-	private final ChronoUnit defaultUnit;
+	private final DurationFormat.Unit defaultUnit;
 
 	/**
 	 * Create a {@code DurationFormatter} following JSR-310's parsing rules for a Duration
@@ -52,25 +51,25 @@ class DurationFormatter implements Formatter<Duration> { //TODO why is this one
 	/**
 	 * Create a {@code DurationFormatter} in a specific {@link DurationFormat.Style}.
 	 * <p>When a unit is needed but cannot be determined (e.g. printing a Duration in the
-	 * {@code SIMPLE} style), {@code ChronoUnit#MILLIS} is used.
+	 * {@code SIMPLE} style), {@code DurationFormat.Unit#MILLIS} is used.
 	 */
 	public DurationFormatter(DurationFormat.Style style) {
 		this(style, null);
 	}
 
 	/**
 	 * Create a {@code DurationFormatter} in a specific {@link DurationFormat.Style} with an
-	 * optional {@code ChronoUnit}.
+	 * optional {@code DurationFormat.Unit}.
 	 * <p>If a {@code defaultUnit} is specified, it may be used in parsing cases when no
 	 * unit is present in the string (provided the style allows for such a case). It will
 	 * also be used as the representation's resolution when printing in the
 	 * {@link DurationFormat.Style#SIMPLE} style. Otherwise, the style defines its default
 	 * unit.
 	 *
 	 * @param style the {@code DurationStyle} to use
-	 * @param defaultUnit the {@code ChronoUnit} to fall back to when parsing and printing
+	 * @param defaultUnit the {@code DurationFormat.Unit} to fall back to when parsing and printing
 	 */
-	public DurationFormatter(DurationFormat.Style style, @Nullable ChronoUnit defaultUnit) {
+	public DurationFormatter(DurationFormat.Style style, @Nullable DurationFormat.Unit defaultUnit) {
 		this.style = style;
 		this.defaultUnit = defaultUnit;
 	}

Diff for: spring-context/src/main/java/org/springframework/format/datetime/standard/DurationFormatterUtils.java

@@ -17,7 +17,6 @@
 package org.springframework.format.datetime.standard;
 
 import java.time.Duration;
-import java.time.temporal.ChronoUnit;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -29,8 +28,8 @@
 /**
  * Support {@code Duration} parsing and printing in several styles, as listed in
  * {@link DurationFormat.Style}.
- * <p>Some styles may not enforce any unit to be present, defaulting to {@code ChronoUnit#MILLIS}
- * in that case. Methods in this class offer overloads that take a {@code ChronoUnit} to
+ * <p>Some styles may not enforce any unit to be present, defaulting to {@code DurationFormat.Unit#MILLIS}
+ * in that case. Methods in this class offer overloads that take a {@link DurationFormat.Unit} to
  * be used as a fall-back instead of the ultimate MILLIS default.
  *
  * @author Phillip Webb
@@ -61,7 +60,7 @@ public static Duration parse(String value, DurationFormat.Style style) {
 	 * will default to ms)
 	 * @return a duration
 	 */
-	public static Duration parse(String value, DurationFormat.Style style, @Nullable ChronoUnit unit) {
+	public static Duration parse(String value, DurationFormat.Style style, @Nullable DurationFormat.Unit unit) {
 		return switch (style) {
 			case ISO8601 -> parseIso8601(value);
 			case SIMPLE -> parseSimple(value, unit);
@@ -86,7 +85,7 @@ public static String print(Duration value, DurationFormat.Style style) {
 	 * to ms)
 	 * @return the printed result
 	 */
-	public static String print(Duration value, DurationFormat.Style style, @Nullable ChronoUnit unit) {
+	public static String print(Duration value, DurationFormat.Style style, @Nullable DurationFormat.Unit unit) {
 		return switch (style) {
 			case ISO8601 -> value.toString();
 			case SIMPLE -> printSimple(value, unit);
@@ -113,7 +112,7 @@ public static Duration detectAndParse(String value) {
 	 * @throws IllegalArgumentException if the value is not a known style or cannot be
 	 * parsed
 	 */
-	public static Duration detectAndParse(String value, @Nullable ChronoUnit unit) {
+	public static Duration detectAndParse(String value, @Nullable DurationFormat.Unit unit) {
 		return parse(value, detect(value), unit);
 	}
 
@@ -134,19 +133,6 @@ public static DurationFormat.Style detect(String value) {
 		throw new IllegalArgumentException("'" + value + "' is not a valid duration, cannot detect any known style");
 	}
 
-	public static long longValueFromUnit(Duration duration, ChronoUnit unit) {
-		return switch (unit) {
-			case NANOS -> duration.toNanos();
-			case MICROS -> duration.toNanos() / 1000L;
-			case MILLIS -> duration.toMillis();
-			case SECONDS -> duration.toSeconds();
-			case MINUTES -> duration.toMinutes();
-			case HOURS -> duration.toHours();
-			case DAYS -> duration.toDays();
-			default -> throw new IllegalArgumentException("'" + unit.name() + "' is not a supported ChronoUnit for simple duration representation");
-		};
-	}
-
 	private static final Pattern ISO_8601_PATTERN = Pattern.compile("^[+-]?[pP].*$");
 	private static final Pattern SIMPLE_PATTERN = Pattern.compile("^([+-]?\\d+)([a-zA-Z]{0,2})$");
 
@@ -159,51 +145,25 @@ private static Duration parseIso8601(String value) {
 		}
 	}
 
-	private static Duration parseSimple(String text, @Nullable ChronoUnit fallbackUnit) {
+	private static Duration parseSimple(String text, @Nullable DurationFormat.Unit fallbackUnit) {
 		try {
 			Matcher matcher = SIMPLE_PATTERN.matcher(text);
 			Assert.state(matcher.matches(), "Does not match simple duration pattern");
 			String suffix = matcher.group(2);
-			ChronoUnit parsingUnit = (fallbackUnit == null ? ChronoUnit.MILLIS : fallbackUnit);
+			DurationFormat.Unit parsingUnit = (fallbackUnit == null ? DurationFormat.Unit.MILLIS : fallbackUnit);
 			if (StringUtils.hasLength(suffix)) {
-				parsingUnit = unitFromSuffix(suffix);
+				parsingUnit = DurationFormat.Unit.fromSuffix(suffix);
 			}
-			return Duration.of(Long.parseLong(matcher.group(1)), parsingUnit);
+			return parsingUnit.parse(matcher.group(1));
 		}
 		catch (Exception ex) {
 			throw new IllegalArgumentException("'" + text + "' is not a valid simple duration", ex);
 		}
 	}
 
-	private static String printSimple(Duration duration, @Nullable ChronoUnit unit) {
-		unit = (unit == null ? ChronoUnit.MILLIS : unit);
-		return longValueFromUnit(duration, unit) + suffixFromUnit(unit);
-	}
-
-	/* package-private */ static ChronoUnit unitFromSuffix(String suffix) {
-		return switch (suffix.toLowerCase()) {
-			case "ns" -> ChronoUnit.NANOS;
-			case "us" -> ChronoUnit.MICROS;
-			case "ms" -> ChronoUnit.MILLIS;
-			case "s" -> ChronoUnit.SECONDS;
-			case "m" -> ChronoUnit.MINUTES;
-			case "h" -> ChronoUnit.HOURS;
-			case "d" -> ChronoUnit.DAYS;
-			default -> throw new IllegalArgumentException("'" + suffix + "' is not a valid simple duration unit");
-		};
-	}
-
-	/* package-private */ static String suffixFromUnit(ChronoUnit unit) {
-		return switch (unit) {
-			case NANOS -> "ns";
-			case MICROS -> "us";
-			case MILLIS -> "ms";
-			case SECONDS -> "s";
-			case MINUTES -> "m";
-			case HOURS -> "h";
-			case DAYS -> "d";
-			default -> throw new IllegalArgumentException("'" + unit.name() + "' is not a supported ChronoUnit for simple duration representation");
-		};
+	private static String printSimple(Duration duration, @Nullable DurationFormat.Unit unit) {
+		unit = (unit == null ? DurationFormat.Unit.MILLIS : unit);
+		return unit.print(duration);
 	}
 
 }

Diff for: spring-context/src/test/java/org/springframework/format/datetime/standard/DateTimeFormattingTests.java

@@ -31,7 +31,6 @@
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
 import java.time.format.FormatStyle;
-import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.GregorianCalendar;
@@ -688,7 +687,7 @@ public static class DateTimeBean {
 
 		private Duration duration;
 
-		@DurationFormat(style = Style.SIMPLE, defaultUnit = ChronoUnit.MICROS)
+		@DurationFormat(style = Style.SIMPLE, defaultUnit = DurationFormat.Unit.MICROS)
 		private Duration styleDuration;
 
 		private Year year;