embulk-filter-timestamp_format 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88c7a2edd52859e9304b268ecea6c766158857cd
-  data.tar.gz: 263540b3154fdd4c0a04892db3708b09dac23cc0
+  metadata.gz: 6c2034a4c12e1d4439ed09e907953e99ebca2ab7
+  data.tar.gz: 042b74ef4661bb9c1a629178df7e13c76bab03db
 SHA512:
-  metadata.gz: 08c540df5bab3aeb3f03c3507042f623fead8488126f714a17dfa3ff09a8c536d03c94ed1773cb6fa37b6255d8cf55f86ed454cb4b6cb229c8bc68e5bcee8c27
-  data.tar.gz: 945fb0c472ee3d9cc42bcfb9dda0a4444919773c42a9b4cca13a274e61505475ce2733e8bfc430449103488cddae5617300d9d0f2195cf779fafc24a96716819
+  metadata.gz: eda3234fc719296056ee7640dcf889dc9af2230f14db52c0bb1678d5a08f709a938bd7a8fbf796ce740a64d22f6a7bf7f7a2930a83b2d30152321e1fd485fc7a
+  data.tar.gz: dc28a057caaf95736d2667542253850d569f00ac2fb9181b4d9526e903a0842eefaca635ce2a41f1b5adc00863f21c3443f89905ff1da9848c8d4f2e897d8f38

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.2.0 (2016-05-13)
+
+Enhancements:
+
+* Add `timestamp_format: auto_java` option (experimental)
+
 # 0.1.9 (2016-05-10)
 
 Enhancements:

data/README.md

@@ -19,9 +19,10 @@ A filter plugin for Embulk to change timestamp format
 - **default_from_timezone**: default timezone for the input string (string, default is `UTC`)
 - **default_to_timestamp_format**: default timestamp format for the output string (string, default is `%Y-%m-%d %H:%M:%S.%N %z`)
 - **default_to_timezone**: default timezone for the output string (string, default is `UTC`)
-- **default_from_timestamp_unit**: default time unit such as `second`, `ms`, `us`, `ns` for the input unixtimestamp (string, default is `second`)
-- **default_to_timestamp_unit**: default time unit such as `second`, `ms`, `us`, `ns` for the output unixtimestamp (string, default is `second`)
+- **default_from_timestamp_unit**: default time unit such as `sec` (for second), `ms` (for milli second), `us` (for micro second), `ns` (for nano second) for the input unixtimestamp (string, default is `second`)
+- **default_to_timestamp_unit**: default time unit such as `sec` (for second), `ms` (for milli second), `us` (for micro second), `ns` (for nano second) for the output unixtimestamp (string, default is `second`)
 - **stop_on_invalid_record**: stop bulk load transaction if a invalid record is found (boolean, default is `false`)
+- **timestamp_parser** (experimental): set `auto_java` to try to convert ruby format to java format to use faster java timestamp parser (string, default is `auto`)
 
 ## Example
 
@@ -62,9 +63,9 @@ Output will be as:
 
 See [./example](./example) for more examples.
 
-## JRuby Timestamp Parser/Formatter Performance Issue
+## JRuby Timestamp Parser Performance Issue
 
-Embulk's timestamp parser/formatter originally uses jruby implementation, but it is slow.
+Embulk's timestamp parser originally uses jruby implementation, but it is slow.
 To improve performance, this plugin also supports Java's Joda-Time [DateTimeFormat](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) format as:
 
 ```yaml
@@ -90,6 +91,10 @@ out:
 
 If format strings contain `%`, jruby parser/formatter is used. Otherwirse, java parser/formatter is used
 
+**Auto Java timestamp format conversion** (experimental)
+
+If you configure `timestamp_parser: auto_java`, this plugin tries to convert ruby format into java format to use faster java timestamp parser.
+
 **COMPARISON:**
 
 Benchmark test sets are available at [./bench](./bench).  In my environment (Mac Book Pro), for 1000000 timestamps:
@@ -99,9 +104,11 @@ Benchmark test sets are available at [./bench](./bench).  In my environment (Mac
 * jruby parser / java formatter: 64.52s
 * jruby parser / jruby formatter: 65.06s
 
+JRuby parser is slow, but JRuby formatter is not so slow.
+
 ## Nano Resolution
 
-JRuby parser has micro second resolution. Java (Joda-Time) parser has milli second resolution (although Java8's DateTimeFormatter supports nano second resolution)
+JRuby parser has micro second resolution. Java (Joda-Time) parser has milli second resolution.
 
 Nano second resolution is partially supported by this plugin itself. Use parser format `nnnnnnnnn` for Java parser as
 
@@ -118,6 +125,8 @@ yyyy-MM-dd HH:mm:ss.nnnnnnnnn z
 yyyy-MM-dd HH:mm:ss.nnnnnn z
 ```
 
+FYI: Java8's DateTimeFormatter supports nano second resolution, but we can not use it because embulk supports Java7.
+
 ## ToDo
 
 * Write test

data/build.gradle

@@ -13,7 +13,7 @@ configurations {
     provided
 }
 
-version = "0.1.9"
+version = "0.2.0"
 sourceCompatibility = 1.7
 targetCompatibility = 1.7
 
@@ -22,6 +22,7 @@ dependencies {
     provided "org.embulk:embulk-core:0.8.+"
     // compile "YOUR_JAR_DEPENDENCY_GROUP:YOUR_JAR_DEPENDENCY_MODULE:YOUR_JAR_DEPENDENCY_VERSION"
     testCompile "junit:junit:4.+"
+    testCompile "org.embulk:embulk-core:0.7.+:tests"
 }
 
 checkstyle {

data/example/empty.yml

@@ -0,0 +1,9 @@
+in:
+  type: file
+  path_prefix: example/example.jsonl
+  parser:
+    type: json
+filters:
+  - type: timestamp_format
+out:
+  type: "null"

data/example/string_auto_java.yml

@@ -0,0 +1,24 @@
+in:
+  type: file
+  path_prefix: example/string.csv
+  parser:
+    type: csv
+    columns:
+      - {name: string1, type: string}
+      - {name: string2, type: string}
+      - {name: string3, type: string}
+      - {name: string4, type: string}
+filters:
+  - type: timestamp_format
+    default_from_timezone: "Asia/Taipei"
+    default_from_timestamp_format: ["%Y-%m-%d", "%Y-%m-%d %Z", "%Y-%m-%d %H:%M:%S.%N %Z", "%Y-%m-%d %H:%M:%S %Z", "%Y-%m-%d %H:%M:%S"]
+    default_to_timezone: "Asia/Taipei"
+    default_to_timestamp_format: "%Y-%m-%d %H:%M:%S.%N"
+    timestamp_parser: auto_java
+    columns:
+      - {name: string1}
+      - {name: string2, type: timestamp}
+      - {name: string3, type: long, to_unit: ms}
+      - {name: string4, type: double, to_unit: ms}
+out:
+  type: "null"

data/example/string_nano.yml

@@ -13,7 +13,7 @@ filters:
     default_from_timezone: "Asia/Taipei"
     default_from_timestamp_format: ["yyyy-MM-dd", "yyyy-MM-dd z", "yyyy-MM-dd HH:mm:ss.nnnnnnnnn z", "yyyy-MM-dd HH:mm:ss z", "yyyy-MM-dd HH:mm:ss"]
     default_to_timezone: "Asia/Taipei"
-    default_to_timestamp_format: "yyyy-MM-dd HH:mm:ss.nnnnnnnn"
+    default_to_timestamp_format: "yyyy-MM-dd HH:mm:ss.nnnnnn Z"
     columns:
       - {name: string1}
       - {name: string2, type: timestamp}

data/src/main/java/org/embulk/filter/timestamp_format/ColumnCaster.java

@@ -21,6 +21,7 @@ import org.joda.time.DateTimeZone;
 import org.msgpack.value.Value;
 import org.slf4j.Logger;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
@@ -69,7 +70,24 @@ public class ColumnCaster
     {
         DateTimeZone timezone = columnConfig.getFromTimeZone().or(task.getDefaultFromTimeZone());
         List<String> formatList = columnConfig.getFromFormat().or(task.getDefaultFromTimestampFormat());
-        return new TimestampParser(task.getJRuby(), formatList, timezone);
+        List<String> newFormatList = new ArrayList<>(formatList);
+        String name = columnConfig.getName();
+        if (task.getTimeStampParser().equals("auto_java")) {
+            for (int i = 0; i < formatList.size(); i++) {
+                String format = formatList.get(i);
+                if (!format.contains("%")) {
+                    continue;
+                }
+                String javaFormat = TimestampFormatConverter.toJavaFormat(format);
+                if (javaFormat == null) {
+                    logger.info(String.format("%s: Failed to convert ruby parser to java parser: \"%s\", Use ruby parser as is", name, format));
+                } else {
+                    logger.debug(String.format("%s: Convert ruby parser \"%s\" to java parser \"%s\"", name, format, javaFormat));
+                    newFormatList.set(i, javaFormat);
+                }
+            }
+        }
+        return new TimestampParser(task.getJRuby(), newFormatList, timezone);
     }
 
     private void buildTimestampFormatterMap()

data/src/main/java/org/embulk/filter/timestamp_format/TimestampFormatConverter.java

@@ -0,0 +1,147 @@
+package org.embulk.filter.timestamp_format;
+
+// Convert JRuby Time Format into Java (Joda-Time) Format
+// Aimed only for parser (JRuby format is too rich than Java Format in terms of formatter)
+
+import java.util.HashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class TimestampFormatConverter
+{
+    public static final HashMap<String, String> RUBY_TO_JAVA_FORMAT_TABLE = new HashMap<>();
+    private static final Pattern IDENTIFIER_PATTERN;
+    private static final Pattern NON_IDENTIFIER_PATTERN;
+
+    static
+    {
+        // %A<Friday> EEEE<Friday>
+        // %B<May> MMMM<May>
+        // %C<20> CC<20>
+        // %D<05/13/16> MM/dd/yy<05/13/16>
+        // %F<2016-05-13> yyyy-MM-dd<2016-05-13>
+        // %H<09> HH<09>
+        // %I<09> hh<09>
+        // %L<123> SSS<123>
+        // %M<02> mm<02>
+        // %N<123456789> nnnnnnnnn<123456789>
+        // %P<am> a<AM>
+        // %R<09:02> HH:mm<09:02>
+        // %S<39> ss<39>
+        // %T<09:02:39> HH:mm:ss<09:02:39>
+        // %U<19> w<19>
+        // %V<19> w<19>
+        // %W<19> w<19>
+        // %X<09:02:39> HH:mm:ss<09:02:39>
+        // %Y<2016> yyyy<2016>
+        // %Z<UTC> z<UTC>
+        // %a<Fri> EEE<Fri>
+        // %b<May> MMM<May>
+        // %c<Fri May 13 09:02:39 2016> EEE MMM dd HH:mm:ss yyyy<Fri May 13 09:02:39 2016>
+        // %d<13> dd<13>
+        // %e<13> dd<13>
+        // %h<May> MMM<May>
+        // %j<134> DDD<134>
+        // %k< 9> HH<09>
+        // %m<05> MM<05>
+        // %p<AM> a<AM>
+        // %r<09:02:39 AM> hh:mm:ss a<09:02:39 AM>
+        // %u<5> e<5>
+        // %v<13-MAY-2016> dd-MMM-yyyy<13-May-2016>
+        // %w<5> e<5>
+        // %x<05/13/16> MM/dd/yy<05/13/16>
+        // %y<16> yy<16>
+        // %z<+0000> Z<+0000>
+        // %:z<+00:00> Z<+0000>
+        // %::z<+00:00:00> Z<+0000>
+        RUBY_TO_JAVA_FORMAT_TABLE.put("A", "EEEE");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("a", "EEE");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("B", "MMMM");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("b", "MMM");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("C", "CC");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("c", "EEE MMM dd HH:mm:ss yyyy");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("D", "MM/dd/yy");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("d", "dd");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("e", "dd");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("F", "yyyy-MM-dd");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("H", "HH");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("h", "MMM");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("I", "hh");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("j", "DDD");
+        //RUBY_TO_JAVA_FORMAT_TABLE.put("k", "HH"); // " 9" fails with HH
+        RUBY_TO_JAVA_FORMAT_TABLE.put("L", "SSS");
+        //RUBY_TO_JAVA_FORMAT_TABLE.put("l", "hh"); // " 9" fails with hh
+        RUBY_TO_JAVA_FORMAT_TABLE.put("M", "mm");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("m", "MM");
+        //RUBY_TO_JAVA_FORMAT_TABLE.put("n", "");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("N", "nnnnnnnnn");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("P", "a");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("p", "a");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("R", "HH:mm");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("r", "hh:mm:ss a");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("S", "ss");
+        //RUBY_TO_JAVA_FORMAT_TABLE.put("s", "")); // N/A
+        RUBY_TO_JAVA_FORMAT_TABLE.put("T", "HH:mm:ss");
+        //RUBY_TO_JAVA_FORMAT_TABLE.put("t", "");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("U", "w");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("u", "e");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("v", "dd-MMM-yyyy");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("V", "w");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("W", "w");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("w", "e");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("X", "HH:mm:ss");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("x", "MM/dd/yy");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("Y", "yyyy");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("y", "yy");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("Z", "z");
+        RUBY_TO_JAVA_FORMAT_TABLE.put("z", "Z");
+        //RUBY_TO_JAVA_FORMAT_TABLE.put("%", "");
+
+        String[] array = RUBY_TO_JAVA_FORMAT_TABLE.keySet().toArray(new String[0]);
+        StringBuilder keyPatternBuilder = new StringBuilder(array[0]);
+        for (int i = 1; i < array.length; i++) {
+            keyPatternBuilder.append(array[i]);
+        }
+        IDENTIFIER_PATTERN = Pattern.compile(new StringBuilder()
+                .append("%[-_^#0-9:]*([")
+                .append(keyPatternBuilder.toString())
+                .append("])")
+                .toString());
+
+        NON_IDENTIFIER_PATTERN = Pattern.compile("(^|\\s)([^%\\s]\\S*)");
+    }
+
+    // @return returns null if appropriate java format is not available
+    public static String toJavaFormat(String rubyFormat)
+    {
+        String quotedFormat = quoteFormat(rubyFormat);
+        Matcher match = IDENTIFIER_PATTERN.matcher(quotedFormat);
+        StringBuffer buf = new StringBuffer();
+        while (match.find()) {
+            String key = match.group(1);
+            String replacement = RUBY_TO_JAVA_FORMAT_TABLE.get(key);
+            match.appendReplacement(buf, replacement);
+        }
+        match.appendTail(buf);
+        String javaFormat = buf.toString();
+
+        if (javaFormat.contains("%")) {
+            return null; // give up to use java format
+        }
+        else {
+            return javaFormat;
+        }
+    }
+
+    private static String quoteFormat(String rubyFormat)
+    {
+        Matcher match = NON_IDENTIFIER_PATTERN.matcher(rubyFormat);
+        StringBuffer buf = new StringBuffer();
+        while (match.find()) {
+            String replacement = new StringBuilder().append(match.group(1)).append("'").append(match.group(2)).append("'").toString();
+            match.appendReplacement(buf, replacement);
+        }
+        match.appendTail(buf);
+        return buf.toString();
+    }
+}

data/src/main/java/org/embulk/filter/timestamp_format/TimestampFormatFilterPlugin.java

@@ -19,7 +19,6 @@ import org.embulk.spi.PageOutput;
 import org.embulk.spi.PageReader;
 import org.embulk.spi.Schema;
 
-import org.embulk.spi.time.Timestamp;
 import org.embulk.spi.type.BooleanType;
 import org.embulk.spi.type.JsonType;
 import org.embulk.spi.type.TimestampType;
@@ -66,6 +65,10 @@ public class TimestampFormatFilterPlugin implements FilterPlugin
         @ConfigDefault("false")
         Boolean getStopOnInvalidRecord();
 
+        @Config("timestamp_parser")
+        @ConfigDefault("\"auto\"") // or auto_java
+        String getTimeStampParser();
+
         @Config("default_from_timestamp_unit")
         @ConfigDefault("\"second\"")
         TimestampUnit getDefaultFromTimestampUnit();

data/src/main/java/org/embulk/filter/timestamp_format/TimestampFormatter.java

@@ -16,8 +16,6 @@ import org.jruby.embed.ScriptingContainer;
 import org.jruby.util.RubyDateFormat;
 
 import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import org.joda.time.format.DateTimeFormat;
 import org.joda.time.format.DateTimeFormatter;

data/src/main/java/org/embulk/filter/timestamp_format/TimestampUnitDeserializer.java

@@ -21,14 +21,20 @@ public class TimestampUnitDeserializer
         builder.put("MilliSecond", TimestampUnit.MilliSecond);
         builder.put("millisecond", TimestampUnit.MilliSecond);
         builder.put("milli_second", TimestampUnit.MilliSecond);
+        builder.put("milli", TimestampUnit.MilliSecond);
+        builder.put("msec", TimestampUnit.MilliSecond);
         builder.put("ms", TimestampUnit.MilliSecond);
         builder.put("MicroSecond", TimestampUnit.MicroSecond);
         builder.put("microsecond", TimestampUnit.MicroSecond);
         builder.put("micro_second", TimestampUnit.MicroSecond);
+        builder.put("micro", TimestampUnit.MicroSecond);
+        builder.put("usec", TimestampUnit.MicroSecond);
         builder.put("us", TimestampUnit.MicroSecond);
         builder.put("NanoSecond", TimestampUnit.NanoSecond);
         builder.put("nanosecond", TimestampUnit.NanoSecond);
         builder.put("nano_second", TimestampUnit.NanoSecond);
+        builder.put("nano", TimestampUnit.NanoSecond);
+        builder.put("nsec", TimestampUnit.NanoSecond);
         builder.put("ns", TimestampUnit.NanoSecond);
         stringToTimestampUnitMap = builder.build();
     }

data/src/test/java/org/embulk/filter/timestamp_format/TestTimestampFormatConverter.java

@@ -0,0 +1,114 @@
+package org.embulk.filter.timestamp_format;
+
+import org.embulk.EmbulkTestRuntime;
+
+import org.embulk.spi.time.Timestamp;
+import org.joda.time.DateTimeZone;
+import org.jruby.embed.ScriptingContainer;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class TestTimestampFormatConverter
+{
+    @Rule
+    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
+    public ScriptingContainer jruby;
+    public DateTimeZone zone;
+    public Timestamp timestamp;
+
+    @Before
+    public void createResource()
+    {
+        jruby = new ScriptingContainer();
+        zone = DateTimeZone.UTC;
+        timestamp = Timestamp.ofEpochSecond(1463130159, 123456789);
+    }
+
+    @Test
+    public void testRUBY_TO_JAVA_FORMAT_TABLE()
+    {
+        for(Map.Entry<String, String> entry : TimestampFormatConverter.RUBY_TO_JAVA_FORMAT_TABLE.entrySet()) {
+            String rubyFormat = "%" + entry.getKey();
+            String javaFormat = entry.getValue();
+
+            TimestampFormatter rubyFormatter = new TimestampFormatter(jruby, rubyFormat, zone);
+            TimestampFormatter javaFormatter = new TimestampFormatter(jruby, javaFormat, zone);
+            String rubyFormatted = rubyFormatter.format(timestamp);
+            String javaFormatted = javaFormatter.format(timestamp);
+            // System.out.println(String.format("%s<%s> %s<%s>", rubyFormat, rubyFormatted, javaFormat, javaFormatted));
+
+            TimestampParser rubyParser = new TimestampParser(jruby, Arrays.asList("." + rubyFormat), zone);
+            TimestampParser javaParser = new TimestampParser(jruby, Arrays.asList("." + javaFormat), zone);
+            Timestamp rubyParsed = rubyParser.parse("." + rubyFormatted);
+            try {
+                Timestamp javaParsed = javaParser.parse("." + rubyFormatted);
+            }
+            catch (IllegalArgumentException ex) {
+                fail(String.format("Parse \"%s\" with java format \"%s\" failed (corresponding ruby format \"%s\")", rubyFormatted, javaFormat, rubyFormat));
+            }
+        }
+    }
+
+    @Test
+    public void testToJavaFormat()
+    {
+        for(Map.Entry<String, String> entry : TimestampFormatConverter.RUBY_TO_JAVA_FORMAT_TABLE.entrySet()) {
+            String rubyFormat = "%-2" + entry.getKey();
+            String javaFormat = entry.getValue();
+            assertEquals(javaFormat, TimestampFormatConverter.toJavaFormat(rubyFormat));
+        }
+    }
+
+    @Test
+    public void testToJavaFormats()
+    {
+        {
+            String rubyFormat = "%Y-%m-%d %H:%M:%S.%6N %:z";
+            String javaFormat = "yyyy-MM-dd HH:mm:ss.nnnnnnnnn Z";
+            assertEquals(javaFormat, TimestampFormatConverter.toJavaFormat(rubyFormat));
+
+            TimestampParser parser = new TimestampParser(jruby, Arrays.asList(javaFormat), zone);
+            try {
+                parser.parse("2016-05-12 20:14:13.123456789 +09:00");
+            }
+            catch (IllegalArgumentException ex) {
+                fail();
+            }
+        }
+        {
+            String rubyFormat = "%Y-%m-%d %H:%M:%S.%6N UTC";
+            String javaFormat = "yyyy-MM-dd HH:mm:ss.nnnnnnnnn 'UTC'";
+            assertEquals(javaFormat, TimestampFormatConverter.toJavaFormat(rubyFormat));
+
+            TimestampParser parser = new TimestampParser(jruby, Arrays.asList(javaFormat), zone);
+            try {
+                parser.parse("2016-05-12 20:14:13.123456789 UTC");
+            }
+            catch (IllegalArgumentException ex) {
+                fail();
+            }
+        }
+        {
+            String rubyFormat = "%Y-%m-%d %H:%M:%S.%6N +00:00";
+            String javaFormat = "yyyy-MM-dd HH:mm:ss.nnnnnnnnn '+00:00'";
+            assertEquals(javaFormat, TimestampFormatConverter.toJavaFormat(rubyFormat));
+
+            TimestampParser parser = new TimestampParser(jruby, Arrays.asList(javaFormat), zone);
+            try {
+                parser.parse("2016-05-12 20:14:13.123456789 +00:00");
+            }
+            catch (IllegalArgumentException ex) {
+                fail();
+            }
+        }
+    }
+}
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: embulk-filter-timestamp_format
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Naotoshi Seo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,6 +60,7 @@ files:
 - config/checkstyle/checkstyle.xml
 - example/double.csv
 - example/double.yml
+- example/empty.yml
 - example/example.jsonl
 - example/example.yml
 - example/example2.csv
@@ -74,6 +75,7 @@ files:
 - example/long.yml
 - example/string.csv
 - example/string.yml
+- example/string_auto_java.yml
 - example/string_java.yml
 - example/string_nano.yml
 - example/timestamp.csv
@@ -87,6 +89,7 @@ files:
 - src/main/java/org/embulk/filter/timestamp_format/ColumnVisitorImpl.java
 - src/main/java/org/embulk/filter/timestamp_format/JsonCaster.java
 - src/main/java/org/embulk/filter/timestamp_format/JsonVisitor.java
+- src/main/java/org/embulk/filter/timestamp_format/TimestampFormatConverter.java
 - src/main/java/org/embulk/filter/timestamp_format/TimestampFormatFilterPlugin.java
 - src/main/java/org/embulk/filter/timestamp_format/TimestampFormatter.java
 - src/main/java/org/embulk/filter/timestamp_format/TimestampParser.java
@@ -96,8 +99,9 @@ files:
 - src/main/java/org/embulk/filter/timestamp_format/cast/LongCast.java
 - src/main/java/org/embulk/filter/timestamp_format/cast/StringCast.java
 - src/main/java/org/embulk/filter/timestamp_format/cast/TimestampCast.java
+- src/test/java/org/embulk/filter/timestamp_format/TestTimestampFormatConverter.java
 - src/test/java/org/embulk/filter/timestamp_format/TestTimestampUnit.java
-- classpath/embulk-filter-timestamp_format-0.1.9.jar
+- classpath/embulk-filter-timestamp_format-0.2.0.jar
 homepage: https://github.com/sonots/embulk-filter-timestamp_format
 licenses:
 - MIT