jrjackson 0.1.1 → 0.2.0

data/lib/jrjackson/version.rb

@@ -1,4 +1,3 @@
-
 module JrJackson
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/pom.xml

@@ -5,10 +5,10 @@
   <groupId>com.jrjackson.jruby</groupId>
   <artifactId>jrjackson</artifactId>
   <packaging>jar</packaging>
-  <version>1.0</version>
+  <version>1.2.2</version>
   <name>jrjackson</name>
   <url>http://maven.apache.org</url>
-
+  
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
@@ -28,17 +28,22 @@
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.1.4</version>
+      <version>2.2.2</version>
     </dependency>
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-annotations</artifactId>
-      <version>2.1.4</version>
+      <version>2.2.2</version>
     </dependency>
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
-      <version>2.1.4</version>
+      <version>2.2.2</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.module</groupId>
+      <artifactId>jackson-module-afterburner</artifactId>
+      <version>2.2.2</version>
     </dependency>
   </dependencies>
   <build>
@@ -46,16 +51,16 @@
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
-          <version>3.0</version>
+          <version>3.1</version>
           <configuration>
-            <source>1.6</source>
-            <target>1.6</target>
+            <source>1.7</source>
+            <target>1.7</target>
           </configuration>
         </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
-            <version>2.12.2</version>
+            <version>2.16</version>
             <configuration>
                 <parallel>methods</parallel>
                 <threadCount>10</threadCount>
@@ -64,7 +69,7 @@
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-shade-plugin</artifactId>
-            <version>1.6</version>
+            <version>2.1</version>
             <executions>
                 <execution>
                     <phase>package</phase>

data/src/main/java/com/jrjackson/JrJacksonRaw.java

@@ -4,51 +4,135 @@ import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyObject;
 import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.RubyHash;
 import org.jruby.RubyIO;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.anno.JRubyModule;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.ext.stringio.RubyStringIO;
 import org.jruby.java.addons.IOJavaAddons;
-import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.util.RubyDateFormat;
 
 import java.io.InputStream;
 import java.io.IOException;
-import java.text.DateFormat;
 import java.util.*;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.core.JsonProcessingException;
 
 @JRubyModule(name = "JrJacksonRaw")
 public class JrJacksonRaw extends RubyObject {
-  protected static final ObjectMapper mapper = new ObjectMapper();
+  private static final HashMap<String, ObjectMapper> mappers = new HashMap<String, ObjectMapper>(3);
+  private static final HashMap<String, RubySymbol> symbols = new HashMap<String, RubySymbol>(3);
+
+  private static final Ruby _ruby = Ruby.getGlobalRuntime();
 
   static {
-    mapper.setDateFormat(new RubyDateFormat("yyyy-MM-dd HH:mm:ss z", Locale.US, true));
+    mappers.put("str",
+      RubyJacksonModule.mappedAs("str")
+    );
+    mappers.put("sym",
+      RubyJacksonModule.mappedAs("sym")
+    );
+    mappers.put("raw",
+      RubyJacksonModule.mappedAs("raw")
+    );
+    symbols.put("sym",
+      RubyUtils.rubySymbol(_ruby, "symbolize_keys")
+    );
+    symbols.put("raw",
+      RubyUtils.rubySymbol(_ruby, "raw")
+    );
+    symbols.put("bigdecimal",
+      RubyUtils.rubySymbol(_ruby, "use_bigdecimal")
+    );
   }
 
   public JrJacksonRaw(Ruby ruby, RubyClass metaclass) {
     super(ruby, metaclass);
   }
 
-  @JRubyMethod(module = true, name = {"parse", "load"}, required = 1)
-  public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject arg) {
+  private static boolean flagged(RubyHash opts, String key) {
+    Object val = opts.get(symbols.get(key));
+    if (val == null) {
+      return false;
+    }
+    return (Boolean) val;
+  }
+
+  // deserialize
+  @JRubyMethod(module = true, name = {"parse", "load"}, required = 2)
+  public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject arg, IRubyObject opts)
+    throws IOException
+  {
+    RubyHash options = null;
+    String key = "str";
+    ObjectMapper local;
+
+    if (opts != context.nil) {
+      options = opts.convertToHash();
+      if (flagged(options, "sym")) {
+        key = "sym";
+      }
+      if (flagged(options, "raw")) {
+        key = "raw";
+      }
+      local = mappers.get(key).copy();
+      if (flagged(options, "bigdecimal")) {
+        local.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
+      }
+      else {
+        local.disable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
+      }
+    }
+    else {
+      local = mappers.get(key).copy();
+    }
+    return _parse(context, arg, local);
+  }
+
+  @JRubyMethod(module = true, name = {"parse_raw", "load_raw"}, required = 1)
+  public static IRubyObject parse_raw(ThreadContext context, IRubyObject self, IRubyObject arg)
+    throws IOException
+  {
+    return _parse(context, arg, mappers.get("raw"));
+  }
+
+  @JRubyMethod(module = true, name = {"parse_sym", "load_sym"}, required = 1)
+  public static IRubyObject parse_sym(ThreadContext context, IRubyObject self, IRubyObject arg)
+    throws IOException
+  {
+    return _parse(context, arg, mappers.get("sym"));
+  }
+
+  @JRubyMethod(module = true, name = {"parse_str", "load_str"}, required = 1)
+  public static IRubyObject parse_str(ThreadContext context, IRubyObject self, IRubyObject arg)
+    throws IOException
+  {
+    return _parse(context, arg, mappers.get("str"));
+  }
+
+  public static IRubyObject _parse(ThreadContext context, IRubyObject arg, ObjectMapper mapper) 
+    throws IOException
+  {
     Ruby ruby = context.getRuntime();
+
     try {
       Object o;
       if (arg instanceof RubyString) {
-        o = mapper.readValue(arg.toString(), Object.class);
+        o = mapper.readValue(
+          arg.toString(), Object.class
+        );
       } else if ((arg instanceof RubyIO) || (arg instanceof RubyStringIO)) {
         IRubyObject stream = IOJavaAddons.AnyIO.any_to_inputstream(context, arg);
-        o =  mapper.readValue((InputStream)stream.toJava(InputStream.class), Object.class);
+        o = mapper.readValue((InputStream)stream.toJava(InputStream.class), Object.class);
       } else {
         throw ruby.newArgumentError("Unsupported source. This method accepts String or IO");
       }
-      return (RubyObject)JavaUtil.convertJavaToRuby(ruby, o);
+      return RubyUtils.rubyObject(ruby, o);
     }
     catch (JsonProcessingException e) {
       throw ParseError.newParseError(ruby, e.getLocalizedMessage());
@@ -58,13 +142,14 @@ public class JrJacksonRaw extends RubyObject {
     }
   }
 
+  // serialize
   @JRubyMethod(module = true, name = {"generate", "dump"}, required = 1)
   public static IRubyObject generate(ThreadContext context, IRubyObject self, IRubyObject arg) {
     Ruby ruby = context.getRuntime();
     Object obj = arg.toJava(Object.class);
     try {
-      String s = mapper.writeValueAsString(obj);
-      return ruby.newString(s);
+      String s = mappers.get("raw").writeValueAsString(obj);
+      return RubyUtils.rubyString(ruby, s);
     }
     catch (JsonProcessingException e) {
       throw ParseError.newParseError(ruby, e.getLocalizedMessage());

data/src/main/java/com/jrjackson/JrJacksonService.java

@@ -13,15 +13,9 @@ public class JrJacksonService implements BasicLibraryService {
   public boolean basicLoad(final Ruby ruby) throws IOException {
     RubyModule jr_jackson = ruby.defineModule("JrJackson");
 
-    RubyModule jr_jackson_str = ruby.defineModuleUnder("Str", jr_jackson);
-    jr_jackson_str.defineAnnotatedMethods(JrJacksonStr.class);
-
     RubyModule jr_jackson_raw = ruby.defineModuleUnder("Raw", jr_jackson);
     jr_jackson_raw.defineAnnotatedMethods(JrJacksonRaw.class);
 
-    RubyModule jr_jackson_sym = ruby.defineModuleUnder("Sym", jr_jackson);
-    jr_jackson_sym.defineAnnotatedMethods(JrJacksonSym.class);
-
     RubyClass runtimeError = ruby.getRuntimeError();
     RubyClass parseError = jr_jackson.defineClassUnder("ParseError", runtimeError, runtimeError.getAllocator());
     return true;

data/src/main/java/com/jrjackson/RubyJacksonModule.java

@@ -0,0 +1,74 @@
+package com.jrjackson;
+
+import java.util.*;
+
+import org.jruby.*;
+import org.jruby.util.RubyDateFormat;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.core.util.VersionUtil;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+
+import com.fasterxml.jackson.module.afterburner.AfterburnerModule;
+
+public class RubyJacksonModule extends SimpleModule
+{
+
+  private RubyJacksonModule()
+  {
+    super("JrJacksonStrModule", VersionUtil.versionFor(RubyJacksonModule.class));
+  }
+
+  public static ObjectMapper mappedAs(String key)
+  {
+    ObjectMapper mapper = new ObjectMapper();
+    
+    mapper.registerModule(
+      new AfterburnerModule()
+    );
+
+    if (key == "sym") {
+      mapper.registerModule(
+        asSym()
+      );
+    }
+    else if (key == "raw") {
+      mapper.registerModule(
+        asRaw()
+      );
+    }
+    else {
+      mapper.registerModule(
+        asStr()
+      );
+    }
+    mapper.setDateFormat(new RubyDateFormat("yyyy-MM-dd HH:mm:ss z", Locale.US, true));
+    return mapper;
+  }
+
+  public static SimpleModule asRaw()
+  { 
+    return new RubyJacksonModule().addSerializer(
+      RubySymbol.class, ToStringSerializer.instance
+    );
+  }
+
+  public static SimpleModule asSym()
+  { 
+    return new RubyJacksonModule().addSerializer(
+      RubySymbol.class, ToStringSerializer.instance
+    ).addDeserializer(
+      Object.class, RubyObjectSymDeserializer.instance
+    );
+  }
+
+  public static SimpleModule asStr()
+  { 
+    return new RubyJacksonModule().addSerializer(
+      RubySymbol.class, ToStringSerializer.instance
+    ).addDeserializer(
+      Object.class, RubyObjectStrDeserializer.instance
+    );
+  }
+}

data/src/main/java/com/jrjackson/RubyObjectDeserializer.java

@@ -7,8 +7,6 @@ import com.fasterxml.jackson.core.*;
 
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
-import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
 import com.fasterxml.jackson.databind.util.ObjectBuffer;
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
 
@@ -16,242 +14,160 @@ import org.jruby.Ruby;
 import org.jruby.RubyObject;
 import org.jruby.RubyArray;
 import org.jruby.RubyHash;
-import org.jruby.RubyString;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.javasupport.JavaUtil;
 import org.jruby.javasupport.util.RuntimeHelpers;
 
 
-public class RubyObjectDeserializer
-    extends StdDeserializer<RubyObject>
+public abstract class RubyObjectDeserializer
+  extends StdDeserializer<RubyObject>
 {
-    private static final long serialVersionUID = 1L;
-
-    private final static RubyObject[] NO_OBJECTS = new RubyObject[0];
-
-    protected final static Ruby __ruby__ = Ruby.getGlobalRuntime();
-
-    /**
-     * @since 2.2
-     */
-    public final static RubyObjectDeserializer instance = new RubyObjectDeserializer();
-    
-    public RubyObjectDeserializer() { super(RubyObject.class); }
-
-    /*
-    /**********************************************************
-    /* Deserializer API
-    /**********************************************************
-     */
-    
-    @Override
-    public RubyObject deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        switch (jp.getCurrentToken()) {
-        case START_OBJECT:
-            return mapObject(jp, ctxt);
-        case START_ARRAY:
-            return mapArray(jp, ctxt);
-        case FIELD_NAME:
-            return mapObject(jp, ctxt);
-        case VALUE_EMBEDDED_OBJECT:
-            return toRuby(jp.getEmbeddedObject());
-        case VALUE_STRING:
-            return rubyString(jp);
-
-        case VALUE_NUMBER_INT:
-            /* [JACKSON-100]: caller may want to get all integral values
-             * returned as BigInteger, for consistency
-             */
-            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
-                return toRuby(jp.getBigIntegerValue()); // should be optimal, whatever it is
-            }
-            return toRuby(jp.getNumberValue()); // should be optimal, whatever it is
-
-        case VALUE_NUMBER_FLOAT:
-            /* [JACKSON-72]: need to allow overriding the behavior regarding
-             *   which type to use
-             */
-            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
-                return toRuby(jp.getDecimalValue());
-            }
-            return toRuby(Double.valueOf(jp.getDoubleValue()));
-
-        case VALUE_TRUE:
-            return __ruby__.newBoolean(Boolean.TRUE);
-        case VALUE_FALSE:
-            return __ruby__.newBoolean(Boolean.FALSE);
-
-        case VALUE_NULL: // should not get this but...
-            return null;
-
-        case END_ARRAY: // invalid
-        case END_OBJECT: // invalid
-        default:
-            throw ctxt.mappingException(Object.class);
-        }
-    }
-
-    @Override
-    public RubyObject deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-        throws IOException, JsonProcessingException
-    {
-        JsonToken t = jp.getCurrentToken();
-        switch (t) {
-        // First: does it look like we had type id wrapping of some kind?
-        case START_ARRAY:
-        case START_OBJECT:
-        case FIELD_NAME:
-            /* Output can be as JSON Object, Array or scalar: no way to know
-             * a this point:
-             */
-            return toRuby(typeDeserializer.deserializeTypedFromAny(jp, ctxt));
-
-        /* Otherwise we probably got a "native" type (ones that map
-         * naturally and thus do not need or use type ids)
+  private static final long serialVersionUID = 1L;
+
+  private final static RubyObject[] NO_OBJECTS = new RubyObject[0];
+
+  protected final static Ruby __ruby__ = Ruby.getGlobalRuntime();
+
+  /**
+   * @since 2.2
+  */
+  
+  public RubyObjectDeserializer() { super(RubyObject.class); }
+
+  protected abstract RubyObject convertKey(JsonParser jp)
+  throws IOException;
+
+  /**
+  /**********************************************************
+  /* Deserializer API
+  /**********************************************************
+   */
+  
+  @Override
+  public RubyObject deserialize(JsonParser jp, DeserializationContext ctxt)
+    throws IOException, JsonProcessingException
+  {
+    switch (jp.getCurrentToken()) {
+      case START_OBJECT:
+        return mapObject(jp, ctxt);
+
+      case START_ARRAY:
+        return mapArray(jp, ctxt);
+
+      case FIELD_NAME:
+        return convertKey(jp);
+
+      case VALUE_EMBEDDED_OBJECT:
+        return RubyUtils.rubyObject(__ruby__, jp.getEmbeddedObject());
+
+      case VALUE_STRING:
+        return RubyUtils.rubyString(__ruby__, jp.getText());
+
+      case VALUE_NUMBER_INT:
+        /* [JACKSON-100]: caller may want to get all integral values
+         * returned as BigInteger, for consistency
          */
-        case VALUE_STRING:
-            return rubyString(jp);
+        if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
+            return RubyUtils.rubyBignum(__ruby__, jp.getBigIntegerValue());
+          }
+        return RubyUtils.rubyFixnum(__ruby__, jp.getLongValue());
+
+      case VALUE_NUMBER_FLOAT:
+        if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
+          return RubyUtils.rubyBigDecimal(__ruby__, jp.getDecimalValue());
+        }
+        return RubyUtils.rubyFloat(__ruby__, jp.getDoubleValue());
 
-        case VALUE_NUMBER_INT:
-            // For [JACKSON-100], see above:
-            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
-                return toRuby(jp.getBigIntegerValue());
-            }
-            /* and as per [JACKSON-839], allow "upgrade" to bigger types: out-of-range
-             * entries can not be produced without type, so this should "just work",
-             * even if it is bit unclean
-             */
-            return toRuby(jp.getNumberValue());
+      case VALUE_TRUE:
+        return __ruby__.newBoolean(Boolean.TRUE);
 
-        case VALUE_NUMBER_FLOAT:
-            // For [JACKSON-72], see above
-            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
-                return toRuby(jp.getDecimalValue());
-            }
-            return __ruby__.newFloat(Double.valueOf(jp.getDoubleValue()));
+      case VALUE_FALSE:
+        return __ruby__.newBoolean(Boolean.FALSE);
 
-        case VALUE_TRUE:
-            return __ruby__.newBoolean(Boolean.TRUE);
-        case VALUE_FALSE:
-            return __ruby__.newBoolean(Boolean.FALSE);
-        case VALUE_EMBEDDED_OBJECT:
-            return toRuby(jp.getEmbeddedObject());
+      case VALUE_NULL: // should not get this but...
+        return null;
 
-        case VALUE_NULL: // should not get this far really but...
-            return null;
-        default:
-            throw ctxt.mappingException(Object.class);
-        }
+      case END_ARRAY: // invalid
+      case END_OBJECT: // invalid
+      default:
+        throw ctxt.mappingException(Object.class);
     }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-    
-    protected RubyObject toRuby(Object o) {
-      return (RubyObject)JavaUtil.convertJavaToRuby(__ruby__, o);
+  }
+
+  /**
+  /**********************************************************
+  /* Internal methods
+  /**********************************************************
+  */
+  
+  /**
+   * Method called to map a JSON Array into a Java value.
+   */
+  protected RubyObject mapArray(JsonParser jp, DeserializationContext ctxt)
+  throws IOException, JsonProcessingException
+  {
+    // if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
+    //     return mapArrayToArray(jp, ctxt);
+    // }
+    // Minor optimization to handle small lists (default size for ArrayList is 10)
+    if (jp.nextToken() == JsonToken.END_ARRAY) {
+      return RubyArray.newArray(__ruby__);
     }
-
-    protected RubyString rubyString(JsonParser jp) throws IOException {
-      return __ruby__.newString(jp.getText());
+    ObjectBuffer buffer = ctxt.leaseObjectBuffer();
+    Object[] values = buffer.resetAndStart();
+    int ptr = 0;
+    long totalSize = 0;
+    do {
+      Object value = deserialize(jp, ctxt);
+      ++totalSize;
+      if (ptr >= values.length) {
+        values = buffer.appendCompletedChunk(values);
+        ptr = 0;
+      }
+      values[ptr++] = value;
+    } while (jp.nextToken() != JsonToken.END_ARRAY);
+      // let's create almost full array, with 1/8 slack
+    RubyArray result = RubyArray.newArray(__ruby__, (totalSize + (totalSize >> 3) + 1));
+    buffer.completeAndClearBuffer(values, ptr, result);
+    return result;
+  }
+
+  /**
+   * Method called to map a JSON Object into a Java value.
+   */
+  protected RubyObject mapObject(JsonParser jp, DeserializationContext ctxt)
+  throws IOException, JsonProcessingException
+  {
+    JsonToken t = jp.getCurrentToken();
+    if (t == JsonToken.START_OBJECT) {
+      t = jp.nextToken();
+    }
+    // 1.6: minor optimization; let's handle 1 and 2 entry cases separately
+    if (t != JsonToken.FIELD_NAME) { // and empty one too
+        // empty map might work; but caller may want to modify... so better just give small modifiable
+      return RubyHash.newHash(__ruby__);
     }
 
-    /**
-     * Method called to map a JSON Array into a Java value.
-     */
-    protected RubyObject mapArray(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        // if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
-        //     return mapArrayToArray(jp, ctxt);
-        // }
-        // Minor optimization to handle small lists (default size for ArrayList is 10)
-        if (jp.nextToken()  == JsonToken.END_ARRAY) {
-            return RubyArray.newArray(__ruby__);
-        }
-        ObjectBuffer buffer = ctxt.leaseObjectBuffer();
-        Object[] values = buffer.resetAndStart();
-        int ptr = 0;
-        long totalSize = 0;
-        do {
-            Object value = deserialize(jp, ctxt);
-            ++totalSize;
-            if (ptr >= values.length) {
-                values = buffer.appendCompletedChunk(values);
-                ptr = 0;
-            }
-            values[ptr++] = value;
-        } while (jp.nextToken() != JsonToken.END_ARRAY);
-        // let's create almost full array, with 1/8 slack
-        RubyArray result = RubyArray.newArray(__ruby__, (totalSize + (totalSize >> 3) + 1));
-        buffer.completeAndClearBuffer(values, ptr, result);
-        return result;
+    RubyObject field1 = convertKey(jp);
+    jp.nextToken();
+    RubyObject value1 = deserialize(jp, ctxt);
+    if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable
+      return RuntimeHelpers.constructHash(__ruby__, field1, value1);
     }
 
-    /**
-     * Method called to map a JSON Object into a Java value.
-     */
-    protected RubyObject mapObject(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        JsonToken t = jp.getCurrentToken();
-        if (t == JsonToken.START_OBJECT) {
-            t = jp.nextToken();
-        }
-        // 1.6: minor optimization; let's handle 1 and 2 entry cases separately
-        if (t != JsonToken.FIELD_NAME) { // and empty one too
-            // empty map might work; but caller may want to modify... so better just give small modifiable
-            return RubyHash.newHash(__ruby__);
-        }
-        RubyString field1 = rubyString(jp);
-        jp.nextToken();
-        RubyObject value1 = deserialize(jp, ctxt);
-        if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable
-            return RuntimeHelpers.constructHash(__ruby__, field1, value1);
-        }
-        RubyString field2 = rubyString(jp);
-        jp.nextToken();
-        RubyObject value2 = deserialize(jp, ctxt);
-        if (jp.nextToken() != JsonToken.FIELD_NAME) {
-            return RuntimeHelpers.constructHash(__ruby__, field1, value1, field2, value2);
-        }
-        // And then the general case; default map size is 16
-        RubyHash result = RuntimeHelpers.constructHash(__ruby__, field1, value1, field2, value2);
-        do {
-            RubyString fieldName = rubyString(jp);
-            jp.nextToken();
-            result.fastASet(fieldName, deserialize(jp, ctxt));
-        } while (jp.nextToken() != JsonToken.END_OBJECT);
-        return result;
+    RubyObject field2 = convertKey(jp);
+    jp.nextToken();
+    RubyObject value2 = deserialize(jp, ctxt);
+    if (jp.nextToken() != JsonToken.FIELD_NAME) {
+      return RuntimeHelpers.constructHash(__ruby__, field1, value1, field2, value2);
     }
 
-    /**
-     * Method called to map a JSON Array into a Java Object array (Object[]).
-     */
-    // protected Object[] mapArrayToArray(JsonParser jp, DeserializationContext ctxt)
-    //     throws IOException, JsonProcessingException
-    // {
-    //     // Minor optimization to handle small lists (default size for ArrayList is 10)
-    //     if (jp.nextToken()  == JsonToken.END_ARRAY) {
-    //         return NO_OBJECTS;
-    //     }
-    //     ObjectBuffer buffer = ctxt.leaseObjectBuffer();
-    //     Object[] values = buffer.resetAndStart();
-    //     int ptr = 0;
-    //     do {
-    //         Object value = deserialize(jp, ctxt);
-    //         if (ptr >= values.length) {
-    //             values = buffer.appendCompletedChunk(values);
-    //             ptr = 0;
-    //         }
-    //         values[ptr++] = value;
-    //     } while (jp.nextToken() != JsonToken.END_ARRAY);
-    //     return buffer.completeAndClearBuffer(values, ptr);
-    // }
+    // And then the general case; default map size is 16
+    RubyHash result = RuntimeHelpers.constructHash(__ruby__, field1, value1, field2, value2);
+    do {
+      RubyObject fieldName = convertKey(jp);
+      jp.nextToken();
+      result.fastASet(fieldName, deserialize(jp, ctxt));
+    } while (jp.nextToken() != JsonToken.END_OBJECT);
+    return result;
+  }
 }