Add support for OffsetDateTime

src/main/java/org/exparity/hamcrest/date/core/DateMatcher.java

@@ -1,6 +1,7 @@
 package org.exparity.hamcrest.date.core;
 
 import java.time.ZoneId;
+import java.time.ZoneOffset;
 
 import org.hamcrest.TypeSafeDiagnosingMatcher;
 
@@ -21,4 +22,14 @@ public abstract class DateMatcher<T> extends TypeSafeDiagnosingMatcher<T> {
      */
     public abstract DateMatcher<T> atZone(ZoneId zone);
 
+    /**
+     * Creates a copy of this matcher using a specific time offset.
+     *
+     * @param offset the new time offset
+     * @return a copy of this matcher based on the new time offset
+     */
+    public DateMatcher<T> atOffset(ZoneOffset offset) {
+        return atZone(ZoneId.of(offset.getId()));
+    }
+
 }

src/main/java/org/exparity/hamcrest/date/core/TemporalConverters.java

@@ -6,6 +6,7 @@
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.Month;
+import java.time.OffsetDateTime;
 import java.time.Year;
 import java.time.ZonedDateTime;
 import java.time.temporal.TemporalAccessor;
@@ -124,7 +125,7 @@ public class TemporalConverters {
 	public static TemporalConverter<LocalDateTime, Second> LOCALDATETIME_AS_SECOND = (date, zone) -> Second.from(date);
 
 	/**
-	 * LocalDateTime Converters
+	 * ZonedDateTime Converters
 	 */
 	public static TemporalConverter<ZonedDateTime, ZonedDateTime> ZONEDDATETIME_AS_ZONEDDATETIME = (date, zone) -> date.withZoneSameInstant(zone);
 	public static TemporalConverter<ZonedDateTime, LocalDate> ZONEDDATETIME_AS_LOCALDATE = (date, zone) -> ZONEDDATETIME_AS_ZONEDDATETIME.apply(date, zone).toLocalDate();
@@ -140,4 +141,17 @@ public class TemporalConverters {
 	 * DayOfWeek Converters
 	 */
 	public static TemporalConverter<DayOfWeek, DayOfWeek> DAYOFWEEK_TO_DAYOFWEEK = (date, zone) -> date;
+
+	/**
+     * {@link OffsetDateTime} Converters
+     */
+    public static TemporalConverter<OffsetDateTime, OffsetDateTime> OFFSETDATETIME_AS_OFFSETDATETIME = (date, zone) -> date.withOffsetSameInstant(zone.getRules().getOffset(date.toLocalDateTime()));    
+    public static TemporalConverter<OffsetDateTime, LocalDate> OFFSETDATETIME_AS_LOCALDATE = (date, zone) -> OFFSETDATETIME_AS_OFFSETDATETIME.apply(date, zone).toLocalDate();
+    public static TemporalConverter<OffsetDateTime, Year> OFFSETDATETIME_AS_YEAR = (date, zone) -> Year.from(OFFSETDATETIME_AS_LOCALDATE.apply(date, zone));
+    public static TemporalConverter<OffsetDateTime, Month> OFFSETDATETIME_AS_MONTH = (date, zone) -> OFFSETDATETIME_AS_LOCALDATE.apply(date, zone).getMonth();
+    public static TemporalConverter<OffsetDateTime, DayOfMonth> OFFSETDATETIME_AS_DAYOFMONTH = (date, zone) -> DayOfMonth.from(OFFSETDATETIME_AS_LOCALDATE.apply(date, zone));
+    public static TemporalConverter<OffsetDateTime, DayOfWeek> OFFSETDATETIME_AS_DAYOFWEEK = (date, zone) -> OFFSETDATETIME_AS_LOCALDATE.apply(date, zone).getDayOfWeek();
+    public static TemporalConverter<OffsetDateTime, Hour> OFFSETDATETIME_AS_HOUR = (date, zone) -> Hour.from(OFFSETDATETIME_AS_OFFSETDATETIME.apply(date, zone));
+    public static TemporalConverter<OffsetDateTime, Minute> OFFSETDATETIME_AS_MINUTE = (date, zone) -> Minute.from(OFFSETDATETIME_AS_OFFSETDATETIME.apply(date, zone));
+    public static TemporalConverter<OffsetDateTime, Second> OFFSETDATETIME_AS_SECOND = (date, zone) -> Second.from(OFFSETDATETIME_AS_OFFSETDATETIME.apply(date, zone));    
 }

src/main/java/org/exparity/hamcrest/date/core/TemporalFunctions.java

@@ -4,6 +4,7 @@
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
 import java.util.Date;
 
@@ -12,6 +13,7 @@
 import org.exparity.hamcrest.date.core.function.LocalDateFunction;
 import org.exparity.hamcrest.date.core.function.LocalDateTimeFunction;
 import org.exparity.hamcrest.date.core.function.LocalTimeFunction;
+import org.exparity.hamcrest.date.core.function.OffsetDateTimeFunction;
 import org.exparity.hamcrest.date.core.function.SqlDateFunction;
 import org.exparity.hamcrest.date.core.function.ZonedDateTimeFunction;
 
@@ -30,5 +32,6 @@ private TemporalFunctions() {}
 	public static TemporalFunction<LocalTime> LOCALTIME = new LocalTimeFunction();
 	public static TemporalFunction<LocalDateTime> LOCALDATETIME = new LocalDateTimeFunction();
 	public static TemporalFunction<ZonedDateTime> ZONEDDATETIME = new ZonedDateTimeFunction();
+    public static TemporalFunction<OffsetDateTime> OFFSETDATETIME = new OffsetDateTimeFunction();
 	public static TemporalFunction<Instant> INSTANT = new InstantFunction();
 }

src/main/java/org/exparity/hamcrest/date/core/TemporalProviders.java

@@ -8,6 +8,7 @@
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.Month;
+import java.time.OffsetDateTime;
 import java.time.Year;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
@@ -96,14 +97,21 @@ public static TemporalProvider<LocalDate> localDate(LocalDate date) {
 	 * Factory to create a {@link TemporalProvider} for a {@link LocalDate}
 	 */
 	public static TemporalProvider<LocalDate> localDate(ZonedDateTime date) {
-		return (zone) -> date.toLocalDate();
+		return (zone) -> zonedDateTime(date).apply(zone).toLocalDate();
 	}
+
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link LocalDate}
+     */
+    public static TemporalProvider<LocalDate> localDate(OffsetDateTime date) {
+        return (zone) -> offsetDateTime(date).apply(zone).toLocalDate();
+    }
 
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link LocalDate}
 	 */
 	public static TemporalProvider<LocalDate> localDate(LocalDateTime date) {
-		return (zone) -> date.toLocalDate();
+		return (zone) -> localDateTime(date).apply(zone).toLocalDate();
 	}
 
 	/**
@@ -138,7 +146,7 @@ public static TemporalProvider<ZonedDateTime> zonedDateTime(Date date) {
 		if (date instanceof java.sql.Date) {
 			return zonedDateTime((java.sql.Date) date);
 		} else {
-			return (zone) -> ZonedDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).withZoneSameInstant(zone);
+			return (zone) -> zonedDateTime(ZonedDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault())).apply(zone);
 		}
 	}
 
@@ -149,6 +157,31 @@ public static TemporalProvider<ZonedDateTime> zonedDateTime(java.sql.Date date)
 		throw new TemporalConversionException(UNSUPPORTED_SQL_DATE_UNIT);
 	}
 
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link OffsetDateTime}
+     */
+    public static TemporalProvider<OffsetDateTime> offsetDateTime(OffsetDateTime date) {
+        return (zone) -> date.withOffsetSameInstant(zone.getRules().getOffset(date.toLocalDateTime()));
+    }
+
+    /**
+     * Factory to create a {@link TemporalProvider} for an {@link OffsetDateTime}
+     */
+    public static TemporalProvider<OffsetDateTime> offsetDateTime(Date date) {
+        if (date instanceof java.sql.Date) {
+            return offsetDateTime((java.sql.Date) date);
+        } else {
+            return (zone) -> offsetDateTime(OffsetDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault())).apply(zone);
+        }
+    }
+
+    /**
+     * Factory to create a {@link TemporalProvider} for an {@link ZonedDateTime}
+     */
+    public static TemporalProvider<OffsetDateTime> offsetDateTime(java.sql.Date date) {
+        throw new TemporalConversionException(UNSUPPORTED_SQL_DATE_UNIT);
+    }
+
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link LocalTime}
 	 */
@@ -160,9 +193,16 @@ public static TemporalProvider<LocalTime> localTime(LocalTime time) {
 	 * Factory to create a {@link TemporalProvider} for a {@link Year}
 	 */
 	public static TemporalProvider<Year> year(ZonedDateTime date) {
-		return (zone) -> Year.from(date.withZoneSameInstant(zone));
+		return (zone) -> Year.from(zonedDateTime(date).apply(zone));
 	}
 
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link Year}
+     */
+    public static TemporalProvider<Year> year(OffsetDateTime date) {
+        return (zone) -> Year.from(offsetDateTime(date).apply(zone));
+    }
+
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link Year}
 	 */
@@ -191,11 +231,18 @@ public static TemporalProvider<Year> year(Date date) {
 		return (zone) -> Year.from(localDate(date).apply(zone));
 	}
 
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link Month}
+     */
+    public static TemporalProvider<Month> month(OffsetDateTime date) {
+        return (zone) -> offsetDateTime(date).apply(zone).getMonth();
+    }
+
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link Month}
 	 */
 	public static TemporalProvider<Month> month(ZonedDateTime date) {
-		return (zone) -> date.withZoneSameInstant(zone).getMonth();
+		return (zone) -> zonedDateTime(date).apply(zone).getMonth();
 	}
 
 	/**
@@ -230,7 +277,7 @@ public static TemporalProvider<Month> month(Date date) {
 	 * Factory to create a {@link TemporalProvider} for a {@link DayOfWeek}
 	 */
 	public static TemporalProvider<List<DayOfWeek>> dayOfWeek(ZonedDateTime date) {
-		return (zone) -> Arrays.asList(date.withZoneSameInstant(zone).getDayOfWeek());
+		return (zone) -> Arrays.asList(zonedDateTime(date).apply(zone).getDayOfWeek());
 	}
 
 	/**
@@ -272,9 +319,16 @@ public static TemporalProvider<List<DayOfWeek>> daysOfWeek(Date date) {
 	 * Factory to create a {@link TemporalProvider} for a {@link DayOfMonth}
 	 */
 	public static TemporalProvider<DayOfMonth> dayOfMonth(ZonedDateTime date) {
-		return (zone) -> DayOfMonth.from(date.withZoneSameInstant(zone));
+		return (zone) -> DayOfMonth.from(zonedDateTime(date).apply(zone));
 	}
 
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link DayOfMonth}
+     */
+    public static TemporalProvider<DayOfMonth> dayOfMonth(OffsetDateTime date) {
+        return (zone) -> DayOfMonth.from(offsetDateTime(date).apply(zone));
+    }
+
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link DayOfMonth}
 	 */
@@ -328,8 +382,16 @@ public static TemporalProvider<Hour> hour(LocalDateTime date) {
 	 * Factory to create a {@link TemporalProvider} for a {@link Hour}
 	 */
 	public static TemporalProvider<Hour> hour(ZonedDateTime date) {
-		return (zone) -> Hour.from(date.withZoneSameInstant(zone));
+		return (zone) -> Hour.from(zonedDateTime(date).apply(zone));
 	}
+
+	   /**
+     * Factory to create a {@link TemporalProvider} for a {@link Hour}
+     */
+    public static TemporalProvider<Hour> hour(OffsetDateTime date) {
+        return (zone) -> Hour.from(offsetDateTime(date).apply(zone));
+    }
+
 
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link Hour}
@@ -363,9 +425,16 @@ public static TemporalProvider<Minute> minute(LocalDateTime date) {
 	 * Factory to create a {@link TemporalProvider} for a {@link Minute}
 	 */
 	public static TemporalProvider<Minute> minute(ZonedDateTime date) {
-		return (zone) -> Minute.from(date.withZoneSameInstant(zone));
+		return (zone) -> Minute.from(zonedDateTime(date).apply(zone));
 	}
 
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link Minute}
+     */
+    public static TemporalProvider<Minute> minute(OffsetDateTime date) {
+        return (zone) -> Minute.from(offsetDateTime(date).apply(zone));
+    }
+
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link Minute}
 	 */
@@ -405,9 +474,16 @@ public static TemporalProvider<Second> second(LocalDateTime date) {
 	 * Factory to create a {@link TemporalProvider} for a {@link Second}
 	 */
 	public static TemporalProvider<Second> second(ZonedDateTime date) {
-		return (zone) -> Second.from(date.withZoneSameInstant(zone));
+		return (zone) -> Second.from(zonedDateTime(date).apply(zone));
 	}
 
+    /**
+     * Factory to create a {@link TemporalProvider} for a {@link Second}
+     */
+    public static TemporalProvider<Second> second(OffsetDateTime date) {
+        return (zone) -> Second.from(offsetDateTime(date).apply(zone));
+    }
+
 	/**
 	 * Factory to create a {@link TemporalProvider} for a {@link Millisecond}
 	 */

src/main/java/org/exparity/hamcrest/date/core/function/OffsetDateTimeFunction.java

@@ -0,0 +1,45 @@
+package org.exparity.hamcrest.date.core.function;
+
+import java.time.OffsetDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.util.Locale;
+
+import org.exparity.hamcrest.date.core.TemporalFunction;
+import org.exparity.hamcrest.date.core.TemporalFunctions;
+import org.exparity.hamcrest.date.core.types.Interval;
+
+/**
+ * Implementation of {@link TemporalFunctions} for {@link OffsetDateTime} objects.
+ *
+ * @author Stewart Bissett
+ */
+public class OffsetDateTimeFunction implements TemporalFunction<OffsetDateTime> {
+
+	private static final String DATE_TIME_PATTERN = "EEE, dd MMM yyyy hh:mm:ss.SSS a Z";
+
+	@Override
+	public boolean isAfter(final OffsetDateTime expected, final OffsetDateTime actual) {
+		return expected.isAfter(actual);
+	}
+
+	@Override
+	public boolean isBefore(final OffsetDateTime expected, final OffsetDateTime actual) {
+		return expected.isBefore(actual);
+	}
+
+	@Override
+	public boolean isSame(final OffsetDateTime expected, final OffsetDateTime actual) {
+		return expected.equals(actual);
+	}
+
+	@Override
+	public Interval interval(OffsetDateTime expected, OffsetDateTime other, ChronoUnit unit) {
+		return Interval.of(expected.until(other, unit), unit);
+	}
+
+	@Override
+	public String describe(final OffsetDateTime temporal, final Locale locale) {
+		return temporal.format(DateTimeFormatter.ofPattern(DATE_TIME_PATTERN, locale));
+	}
+}