Merge branch 'master' of github.com:FasterXML/jackson-databind

Author: cowtowncoder

release-notes/VERSION

@@ -11,6 +11,8 @@ Project: jackson-databind
  (reported by ctytgat@github)
 #1730: InvalidFormatException` for `JsonToken.VALUE_EMBEDDED_OBJECT`
  (reported by zigzago@github)
+#1744: StdDateFormat: add option to serialize timezone offset with a colon
+ (contributed by Bertrand R)
 #1745: StdDateFormat: accept and truncate millis larger than 3 digits
  (suggested by Bertrand R)
 #1749: StdDateFormat: performance improvement of '_format(..)' method 

src/main/java/com/fasterxml/jackson/databind/ObjectMapper.java

@@ -945,7 +945,7 @@ public ObjectMapper registerModules(Module... modules)
      * 
      * @since 2.2
      */
-    public ObjectMapper registerModules(Iterable<Module> modules)
+    public ObjectMapper registerModules(Iterable<? extends Module> modules)
     {
         for (Module module : modules) {
             registerModule(module);

src/main/java/com/fasterxml/jackson/databind/util/StdDateFormat.java

@@ -143,6 +143,13 @@ public class StdDateFormat
 
     private transient DateFormat _formatRFC1123;
 
+    /** 
+     * Whether the TZ offset must be formatted with a colon between hours and minutes ({@code HH:mm} format)
+     *
+     * @since 2.9.1
+     */
+    private boolean _tzSerializedWithColon = false;
+    
     /*
     /**********************************************************
     /* Life cycle, accessing singleton "standard" formats
@@ -160,9 +167,18 @@ public StdDateFormat(TimeZone tz, Locale loc) {
     }
 
     protected StdDateFormat(TimeZone tz, Locale loc, Boolean lenient) {
+        this(tz, loc, lenient, false);
+    }
+
+    /**
+     * @since 2.9.1
+     */
+    protected StdDateFormat(TimeZone tz, Locale loc, Boolean lenient,
+            boolean formatTzOffsetWithColon) {
         _timezone = tz;
         _locale = loc;
         _lenient = lenient;
+        _tzSerializedWithColon = formatTzOffsetWithColon;
     }
 
     public static TimeZone getDefaultTimeZone() {
@@ -180,31 +196,61 @@ public StdDateFormat withTimeZone(TimeZone tz) {
         if ((tz == _timezone) || tz.equals(_timezone)) {
             return this;
         }
-        return new StdDateFormat(tz, _locale, _lenient);
+        return new StdDateFormat(tz, _locale, _lenient, _tzSerializedWithColon);
     }
 
+    /**
+     * "Mutant factory" method that will return an instance that uses specified
+     * {@code Locale}:
+     * either {@code this} instance (if setting would not change), or newly
+     * constructed instance with different {@code Locale} to use.
+     */
     public StdDateFormat withLocale(Locale loc) {
         if (loc.equals(_locale)) {
             return this;
         }
-        return new StdDateFormat(_timezone, loc, _lenient);
+        return new StdDateFormat(_timezone, loc, _lenient, _tzSerializedWithColon);
     }
 
     /**
+     * "Mutant factory" method that will return an instance that has specified leniency
+     * setting: either {@code this} instance (if setting would not change), or newly
+     * constructed instance.
+     *
      * @since 2.9
      */
     public StdDateFormat withLenient(Boolean b) {
         if (_equals(b, _lenient)) {
             return this;
         }
-        return new StdDateFormat(_timezone, _locale, b);
+        return new StdDateFormat(_timezone, _locale, b, _tzSerializedWithColon);
     }
 
+    /**
+     * "Mutant factory" method that will return an instance that has specified
+     * handling of colon when serializing timezone (timezone either written
+     * like {@code +0500} or {@code +05:00}):
+     * either {@code this} instance (if setting would not change), or newly
+     * constructed instance with desired setting for colon inclusion.
+     *<p>
+     * NOTE: does NOT affect deserialization as colon is optional accepted
+     * but not required -- put another way, either serialization is accepted
+     * by this class.
+     *
+     * @since 2.9.1
+     */
+    public StdDateFormat withColonInTimeZone(boolean b) {
+        if (_tzSerializedWithColon == b) {
+            return this;
+        }
+        return new StdDateFormat(_timezone, _locale, _lenient, b);
+     }
+    
     @Override
     public StdDateFormat clone() {
         // Although there is that much state to share, we do need to
         // orchestrate a bit, mostly since timezones may be changed
-        return new StdDateFormat(_timezone, _locale, _lenient);
+        return new StdDateFormat(_timezone, _locale, _lenient, _tzSerializedWithColon);
     }
 
     /**
@@ -280,6 +326,24 @@ public boolean isLenient() {
         return (_lenient == null) || _lenient.booleanValue();
     }
 
+    /**
+     * Accessor for checking whether this instance would include colon
+     * within timezone serialization or not: if {code true}, timezone offset
+     * is serialized like {@code -06:00}; if {code false} as {@code -0600}.
+     *<p>
+     * NOTE: only relevant for serialization (formatting), as deserialization
+     * (parsing) always accepts optional colon but does not require it, regardless
+     * of this setting.
+     *
+     * @return {@code true} if a colon is to be inserted between the hours and minutes 
+     * of the TZ offset when serializing as String; otherwise {@code false}
+     *
+     * @since 2.9.1
+     */
+    public boolean isColonIncludedInTimeZone() {
+        return _tzSerializedWithColon;
+    }
+
     /*
     /**********************************************************
     /* Public API, parsing
@@ -398,15 +462,20 @@ protected void _format(TimeZone tz, Locale loc, Date date,
             int minutes = Math.abs((offset / (60 * 1000)) % 60);
             buffer.append(offset < 0 ? '-' : '+');
             pad2(buffer, hours);
-            // 24-Jun-2017, tatu: To add colon or not to add colon? Both are legal...
-            //   tests appear to expect no colon so let's go with that.
-//            formatted.append(':');
+            if( _tzSerializedWithColon ) {
+            		buffer.append(':');
+            }
             pad2(buffer, minutes);
         } else {
             // 24-Jun-2017, tatu: While `Z` would be conveniently short, older specs
             //   mandate use of full `+0000`
 //            formatted.append('Z');
-            buffer.append("+0000");
+	        	if( _tzSerializedWithColon ) {
+	            buffer.append("+00:00");
+	        	}
+	        	else {
+	        		buffer.append("+0000");
+	        	}
         }
     }
 
@@ -527,7 +596,7 @@ protected Date parseAsISO8601(String dateStr, ParsePosition pos)
         }
     }
 
-    protected Date _parseAsISO8601(String dateStr, ParsePosition pos)
+    protected Date _parseAsISO8601(String dateStr, ParsePosition bogus)
         throws IllegalArgumentException, ParseException
     {
         final int totalLen = dateStr.length();
@@ -611,8 +680,7 @@ protected Date _parseAsISO8601(String dateStr, ParsePosition pos)
                             throw new ParseException(String.format(
 "Cannot parse date \"%s\": invalid fractional seconds '%s'; can use at most 9 digits",
                                        dateStr, m.group(1).substring(1)
-                                       ),
-                                pos.getErrorIndex());
+                                       ), start);
                         }
                         // fall through
                     case 3:
@@ -635,7 +703,9 @@ protected Date _parseAsISO8601(String dateStr, ParsePosition pos)
         throw new ParseException
         (String.format("Cannot parse date \"%s\": while it seems to fit format '%s', parsing fails (leniency? %s)",
                        dateStr, formatStr, _lenient),
-           pos.getErrorIndex());
+                // [databind#1742]: Might be able to give actual location, some day, but for now
+                //  we can't give anything more indicative
+                0);
     }
 
     private static int _parse4D(String str, int index) {

src/test/java/com/fasterxml/jackson/databind/ser/jdk/DateSerializationTest.java

@@ -1,11 +1,24 @@
 package com.fasterxml.jackson.databind.ser.jdk;
 
-import java.io.*;
-import java.text.*;
-import java.util.*;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+
+import org.junit.Assert;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.BaseMapTest;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectWriter;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.util.StdDateFormat;
 
 public class DateSerializationTest
     extends BaseMapTest
@@ -103,9 +116,42 @@ public void testDateISO8601() throws IOException
     {
         ObjectMapper mapper = new ObjectMapper();
         mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
-        // let's hit epoch start
-        String json = mapper.writeValueAsString(new Date(0L));
-        assertEquals("\"1970-01-01T00:00:00.000+0000\"", json);
+
+        serialize( mapper, judate(1970, 1, 1,  02, 00, 00, 0, "GMT+2"), "1970-01-01T00:00:00.000+0000");
+		serialize( mapper, judate(1970, 1, 1,  00, 00, 00, 0, "UTC"),   "1970-01-01T00:00:00.000+0000");
+    }
+    
+    /**
+     * Use a default TZ other than UTC. Dates must be serialized using that TZ.
+     */
+    public void testDateISO8601_customTZ() throws IOException
+    {
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+        mapper.setTimeZone(TimeZone.getTimeZone("GMT+2"));
+
+        serialize( mapper, judate(1970, 1, 1,  00, 00, 00, 0, "GMT+2"), "1970-01-01T00:00:00.000+0200");
+		serialize( mapper, judate(1970, 1, 1,  00, 00, 00, 0, "UTC"),   "1970-01-01T02:00:00.000+0200");
+    }
+
+    /**
+     * Configure the StdDateFormat to serialize TZ offset with a colon between hours and minutes
+     *
+     * See [databind#1744]
+     */
+    public void testDateISO8601_colonInTZ() throws IOException
+    {
+        StdDateFormat dateFormat = new StdDateFormat();
+        assertFalse(dateFormat.isColonIncludedInTimeZone());
+        dateFormat = dateFormat.withColonInTimeZone(true);
+        assertTrue(dateFormat.isColonIncludedInTimeZone());
+
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+        mapper.setDateFormat(dateFormat);
+        
+        serialize( mapper, judate(1970, 1, 1,  02, 00, 00, 0, "GMT+2"), "1970-01-01T00:00:00.000+00:00");
+        serialize( mapper, judate(1970, 1, 1,  00, 00, 00, 0, "UTC"),   "1970-01-01T00:00:00.000+00:00");
     }
 
     public void testDateOther() throws IOException
@@ -114,8 +160,9 @@ public void testDateOther() throws IOException
         DateFormat df = new SimpleDateFormat("yyyy-MM-dd'X'HH:mm:ss");
         mapper.setDateFormat(df);
         mapper.setTimeZone(TimeZone.getTimeZone("PST"));
+
         // let's hit epoch start, offset by a bit
-        assertEquals(quote("1969-12-31X16:00:00"), mapper.writeValueAsString(new Date(0L)));
+        serialize( mapper, judate(1970, 1, 1,  00, 00, 00, 0, "UTC"), "1969-12-31X16:00:00");
     }
 
     public void testTimeZone() throws IOException
@@ -200,19 +247,18 @@ public void testWithTimeZoneOverride() throws Exception
         mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd/HH:mm z"));
         mapper.setTimeZone(TimeZone.getTimeZone("PST"));
         mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
-        String json = mapper.writeValueAsString(new Date(0));
+
         // pacific time is GMT-8; so midnight becomes 16:00 previous day:
-        assertEquals(quote("1969-12-31/16:00 PST"), json);
+        serialize( mapper, judate(1969, 12, 31, 16, 00, 00, 00, "PST"), "1969-12-31/16:00 PST");
 
         // Let's also verify that Locale won't matter too much...
         mapper.setLocale(Locale.FRANCE);
-        json = mapper.writeValueAsString(new Date(0));
-        assertEquals(quote("1969-12-31/16:00 PST"), json);
+        serialize( mapper, judate(1969, 12, 31, 16, 00, 00, 00, "PST"), "1969-12-31/16:00 PST");
 
         // Also: should be able to dynamically change timezone:
         ObjectWriter w = mapper.writer();
         w = w.with(TimeZone.getTimeZone("EST"));
-        json = w.writeValueAsString(new Date(0));
+        String json = w.writeValueAsString(new Date(0));
         assertEquals(quote("1969-12-31/19:00 EST"), json);
     }
 
@@ -272,4 +318,20 @@ public void testFormatWithoutPattern() throws Exception
         String json = mapper.writeValueAsString(new DateAsDefaultBeanWithTimezone(0L));
         assertEquals(aposToQuotes("{'date':'1970-01-01X01:00:00'}"), json);
     }
+    
+    
+    
+	private static Date judate(int year, int month, int day, int hour, int minutes, int seconds, int millis, String tz) {
+		Calendar cal = Calendar.getInstance();
+		cal.set(year, month-1, day, hour, minutes, seconds);
+		cal.set(Calendar.MILLISECOND, millis);
+		cal.setTimeZone(TimeZone.getTimeZone(tz));
+		
+		return cal.getTime();
+	}
+	
+	private void serialize(ObjectMapper mapper, Object date, String expected) throws IOException {
+		String actual = mapper.writeValueAsString(date);
+		Assert.assertEquals(quote(expected), actual);
+	}
 }