jrjackson 0.2.9 → 0.3.0

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

@@ -0,0 +1,117 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonParser;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import static com.jrjackson.JrJacksonBase.flagged;
+import org.jruby.RubyHash;
+import org.jruby.exceptions.RaiseException;
+
+@JRubyModule(name = "JrJacksonRuby")
+public class JrJacksonRuby extends JrJacksonBase {
+
+    public JrJacksonRuby(Ruby ruby, RubyClass metaclass) {
+        super(ruby, metaclass);
+    }
+
+    // deserialize
+    @JRubyMethod(module = true, name = {"parse_sym", "load_sym"}, required = 2)
+    public static Object parse_sym(ThreadContext context, IRubyObject self, IRubyObject arg, IRubyObject opts)
+            throws JsonProcessingException, IOException, RaiseException {
+
+        return __parse(context, arg,
+                new RubySymbolNameConverter(),
+                new RubyBigIntValueConverter(),
+                new RubyBigDecimalValueConverter()
+        );
+    }
+
+    @JRubyMethod(module = true, name = {"parse", "load"}, required = 2)
+    public static Object parse(ThreadContext context, IRubyObject self, IRubyObject arg, IRubyObject opts)
+            throws JsonProcessingException, IOException, RaiseException {
+
+        RubyNameConverter konv = new RubyStringNameConverter();
+        RubyConverter ikonv = new RubyBigIntValueConverter();
+        RubyConverter dkonv = new RubyBigDecimalValueConverter();
+        if (opts != context.nil) {
+            RubyHash options = opts.convertToHash();
+            if (options.size() > 0) {
+                if (flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "symbolize_keys"))) {
+                    konv = new RubySymbolNameConverter();
+                }
+                if (!flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "use_bigdecimal"), true)) {
+                    dkonv = new RubyFloatValueConverter();
+                }
+                if (flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "use_smallint"))) {
+                    ikonv = new RubyIntValueConverter();
+                }
+            }
+        }
+        return __parse(context, arg, konv, ikonv, dkonv);
+    }
+
+    @JRubyMethod(module = true, name = {"compat_parse", "compat_load"}, required = 2)
+    public static Object compat_parse(ThreadContext context, IRubyObject self, IRubyObject arg, IRubyObject opts)
+            throws JsonProcessingException, IOException, RaiseException {
+        RubyKeyConverter konv = new RubyStringKeyConverter();
+        RubyConverter dkonv = new RubyBigDecimalValueConverter();
+        RubyConverter ikonv = new RubyBigIntValueConverter();
+
+        if (opts != context.nil) {
+            RubyHash options = opts.convertToHash();
+            if (options.size() > 0) {
+                if (flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "symbolize_keys"))) {
+                    konv = new RubySymbolKeyConverter();
+                }
+                if (!flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "use_bigdecimal"), true)) {
+                    dkonv = new RubyFloatValueConverter();
+                }
+                if (flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "use_smallint"))) {
+                    ikonv = new RubyIntValueConverter();
+                }
+            }
+        }
+        ObjectMapper om = RubyJacksonModule.mapperWith(context.runtime, konv, ikonv, dkonv);
+
+        return _parse(context, arg, om);
+    }
+
+    private static Object __parse(ThreadContext context, IRubyObject arg,
+                RubyNameConverter keykonv, RubyConverter intconv, RubyConverter decimalconv)
+            throws JsonProcessingException, IOException, RaiseException {
+
+        RubyHandler handler = new RubyHandler(context,
+                keykonv,
+                intconv,
+                decimalconv);
+        JrParse parse = new JrParse(handler);
+        ObjectMapper mapper = RubyJacksonModule.rawBigNumberMapper();
+        JsonFactory jf = mapper.getFactory();
+        JsonParser jp;
+        try {
+            jp = buildParser(context, jf, arg);
+        } catch (IOException e) {
+            throw context.runtime.newIOError(e.getLocalizedMessage());
+        }
+
+        parse.deserialize(jp);
+        jp.close();
+        return handler.getResult();
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.exceptions.RaiseException;
+
+@JRubyModule(name = "JrJacksonSaj")
+public class JrJacksonSaj extends JrJacksonBase {
+
+    public JrJacksonSaj(Ruby ruby, RubyClass metaclass) {
+        super(ruby, metaclass);
+    }
+
+    // deserialize
+    @JRubyMethod(module = true, name = {"parse", "load"}, required = 3)
+    public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject handler, IRubyObject arg, IRubyObject opts)
+            throws RaiseException {
+        StreamParse sp = new SajParse(context, handler);
+        return _sjcparse(context, handler, arg, opts, sp);
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+
+@JRubyModule(name = "JrJacksonSch")
+public class JrJacksonSch extends JrJacksonBase {
+
+    public JrJacksonSch(Ruby ruby, RubyClass metaclass) {
+        super(ruby, metaclass);
+    }
+
+    // deserialize
+    @JRubyMethod(module = true, name = {"parse", "load"}, required = 3)
+    public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject handler, IRubyObject arg, IRubyObject opts)
+            throws RaiseException {
+        StreamParse sp = new SchParse(context, handler);
+        return _sjcparse(context, handler, arg, opts, sp);
+    }
+}

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

@@ -13,9 +13,24 @@ public class JrJacksonService implements BasicLibraryService {
     public boolean basicLoad(final Ruby ruby) throws IOException {
         RubyModule jr_jackson = ruby.defineModule("JrJackson");
 
+        RubyModule jr_jackson_base = ruby.defineModuleUnder("Base", jr_jackson);
+        jr_jackson_base.defineAnnotatedMethods(JrJacksonBase.class);
+
         RubyModule jr_jackson_raw = ruby.defineModuleUnder("Raw", jr_jackson);
         jr_jackson_raw.defineAnnotatedMethods(JrJacksonRaw.class);
 
+        RubyModule jr_jackson_ruby = ruby.defineModuleUnder("Ruby", jr_jackson);
+        jr_jackson_ruby.defineAnnotatedMethods(JrJacksonRuby.class);
+        
+        RubyModule jr_jackson_java = ruby.defineModuleUnder("Java", jr_jackson);
+        jr_jackson_java.defineAnnotatedMethods(JrJacksonJava.class);
+        
+        RubyModule jr_jackson_saj = ruby.defineModuleUnder("Saj", jr_jackson);
+        jr_jackson_saj.defineAnnotatedMethods(JrJacksonSaj.class);
+        
+        RubyModule jr_jackson_sch = ruby.defineModuleUnder("Sch", jr_jackson);
+        jr_jackson_sch.defineAnnotatedMethods(JrJacksonSch.class);
+        
         RubyClass runtimeError = ruby.getRuntimeError();
         RubyClass parseError = jr_jackson.defineClassUnder("ParseError", runtimeError, runtimeError.getAllocator());
         return true;

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

@@ -0,0 +1,149 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonStreamContext;
+import java.io.IOException;
+import java.util.HashMap;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.runtime.builtin.IRubyObject;
+
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class JrParse {
+    private final RubyHandler _handler;
+    protected final HashMap<JsonStreamContext, IRubyObject> _objectMap = new HashMap<JsonStreamContext, IRubyObject>();
+    protected JsonStreamContext _deepestContext;
+    
+    public JrParse(RubyHandler handler) {
+        _handler = handler;
+        
+    }
+    
+    public void deserialize(JsonParser jp) throws JsonProcessingException, IOException {
+        try {
+            
+            while (jp.nextValue() != null) {
+                handleCurrentToken(jp);
+            }
+            
+        } catch (JsonProcessingException e) {
+            _handler.raiseError(e.getLocalizedMessage());
+        } catch (IOException e) {
+            _handler.raiseError(e.getLocalizedMessage());
+        }
+    }
+    
+    private void callAddValue(JsonStreamContext x) {
+        JsonStreamContext px = x.getParent();
+        IRubyObject dtarget = _objectMap.get(_deepestContext);
+        
+        if (px == null) {
+            _handler.addValue(dtarget);
+            return;
+        }
+        
+        IRubyObject value = _objectMap.get(x);
+
+        if (x.inArray()) {
+            _handler.arrayAppend(
+                    (RubyArray)value, dtarget);
+        } else if (x.inObject()) {
+            _handler.hashSet(
+                    (RubyHash)value, callHashKey(x), dtarget);
+
+        } else {
+            _handler.addValue(value);
+        }
+    }
+    
+    private void callAddValue(JsonStreamContext x, IRubyObject val) {
+        
+        if (x.inArray()) {
+            RubyArray a = (RubyArray)_objectMap.get(x);
+            _handler.arrayAppend(a, val);
+        } else if (x.inObject()) {
+            RubyHash h = (RubyHash)_objectMap.get(x);
+            _handler.hashSet(h, callHashKey(x), val);
+            
+        } else {
+            _handler.addValue(val);
+        }
+    }
+    
+    private IRubyObject callHashKey(JsonStreamContext x) {
+        String k = x.getCurrentName();
+        if (k == null) {
+            return _handler.treatNull();
+        }
+        return _handler.hashKey(k);
+    }
+    
+    private void handleCurrentToken(JsonParser jp)
+            throws IOException, JsonProcessingException {
+        
+        JsonStreamContext cx = jp.getParsingContext();
+        
+        switch (jp.getCurrentToken()) {
+            case START_OBJECT:
+                _deepestContext = cx;
+                _objectMap.put(cx, _handler.hashStart());
+                break;
+                
+            case START_ARRAY:
+                _deepestContext = cx;
+                _objectMap.put(cx, _handler.arrayStart());
+                
+            case FIELD_NAME:
+                break;
+                
+            case VALUE_EMBEDDED_OBJECT:
+                System.out.println("-------- VALUE_EMBEDDED_OBJECT ????????? --------");
+                System.out.println(jp.getEmbeddedObject());
+                break;
+                
+            case VALUE_STRING:
+                callAddValue(cx, 
+                        _handler.treatString(jp));
+                break;
+            
+            case VALUE_NUMBER_INT:
+                callAddValue(cx,
+                        _handler.treatInt(jp));
+                break;
+                
+            case VALUE_NUMBER_FLOAT:
+                callAddValue(cx,
+                        _handler.treatFloat(jp));
+                break;
+                
+            case VALUE_TRUE:
+                callAddValue(cx, _handler.trueValue());
+                break;
+
+            case VALUE_FALSE:
+                callAddValue(cx, _handler.falseValue());
+                break;
+
+            case VALUE_NULL: // should not get this but...
+                callAddValue(cx, _handler.treatNull());
+                break;
+
+            case END_ARRAY:
+                _handler.arrayEnd();
+                callAddValue(cx);
+                _deepestContext = cx;
+                break;
+
+            case END_OBJECT:
+                _handler.hashEnd();
+                callAddValue(cx);
+                _deepestContext = cx;
+                break;
+        }
+    }
+}

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

@@ -1,46 +1,43 @@
 package com.jrjackson;
 
-import java.io.IOException;
-import java.util.*;
-
-import com.fasterxml.jackson.core.*;
-
-import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import com.fasterxml.jackson.core.JsonGenerationException;
+import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.databind.SerializerProvider;
-
 import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import org.jruby.*;
 import org.jruby.ext.bigdecimal.RubyBigDecimal;
-import org.jruby.runtime.ThreadContext;
+
 import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.java.proxies.JavaProxy;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-public class RubyAnySerializer extends StdSerializer<IRubyObject> {
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import org.jruby.RubyArray;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyHash;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubyStruct;
+import org.jruby.RubySymbol;
+import org.jruby.RubyTime;
+
+public class RubyAnySerializer {
 
     /**
-     * Singleton instance to use.
+     * Singleton instance to use.""
      */
     public static final RubyAnySerializer instance = new RubyAnySerializer();
-    private static final HashMap<Class, Class> class_maps = new HashMap<Class, Class>();
-
-    static {
-        // not need now - clean up required
-        class_maps.put(RubyBoolean.class, Boolean.class);
-        class_maps.put(RubyFloat.class, Double.class);
-        class_maps.put(RubyFixnum.class, Long.class);
-        class_maps.put(RubyBignum.class, BigInteger.class);
-        class_maps.put(RubyBigDecimal.class, BigDecimal.class);
-    }
 
     public RubyAnySerializer() {
-        super(IRubyObject.class);
-    }
+//        super(IRubyObject.class);
 
-    private Class<?> rubyJavaClassLookup(Class target) {
-        return class_maps.get(target);
     }
 
     private void serializeUnknownRubyObject(ThreadContext ctx, IRubyObject rubyObject, JsonGenerator jgen, SerializerProvider provider)
@@ -50,29 +47,39 @@ public class RubyAnySerializer extends StdSerializer<IRubyObject> {
         DynamicMethod method = meta.searchMethod("to_time");
         if (!method.isUndefined()) {
             RubyTime dt = (RubyTime) method.call(ctx, rubyObject, meta, "to_time");
-            String time = RubyUtils.jodaTimeString(dt.getDateTime());
-            jgen.writeString(time);
+            serializeTime(dt, jgen, provider);
             return;
         }
 
         method = meta.searchMethod("to_h");
         if (!method.isUndefined()) {
             RubyObject obj = (RubyObject) method.call(ctx, rubyObject, meta, "to_h");
-            provider.findTypedValueSerializer(Map.class, true, null).serialize(obj, jgen, provider);
+            serializeHash(obj, jgen, provider);
             return;
         }
 
         method = meta.searchMethod("to_hash");
         if (!method.isUndefined()) {
             RubyObject obj = (RubyObject) method.call(ctx, rubyObject, meta, "to_hash");
-            provider.findTypedValueSerializer(Map.class, true, null).serialize(obj, jgen, provider);
+            serializeHash(obj, jgen, provider);
             return;
         }
 
         method = meta.searchMethod("to_a");
         if (!method.isUndefined()) {
             RubyObject obj = (RubyObject) method.call(ctx, rubyObject, meta, "to_a");
-            provider.findTypedValueSerializer(List.class, true, null).serialize(obj, jgen, provider);
+            serializeArray(obj, jgen, provider);
+            return;
+        }
+
+        method = meta.searchMethod("to_json_data");
+        if (!method.isUndefined()) {
+            RubyObject obj = (RubyObject) method.call(ctx, rubyObject, meta, "to_json_data");
+            if (obj instanceof RubyString) {
+                RubyUtils.writeBytes(obj, jgen);
+            } else {
+                serialize(obj, jgen, provider);
+            }
             return;
         }
 
@@ -80,30 +87,36 @@ public class RubyAnySerializer extends StdSerializer<IRubyObject> {
         if (!method.isUndefined()) {
             RubyObject obj = (RubyObject) method.call(ctx, rubyObject, meta, "to_json");
             if (obj instanceof RubyString) {
+
                 jgen.writeRawValue(obj.toString());
             } else {
-                provider.defaultSerializeValue(obj, jgen);
+                serialize(obj, jgen, provider);
             }
             return;
         }
         throw new JsonGenerationException("Cannot find Serializer for class: " + rubyObject.getClass().getName());
     }
 
-    @Override
+//    @Override
     public void serialize(IRubyObject value, JsonGenerator jgen, SerializerProvider provider)
             throws IOException, JsonGenerationException {
-        ThreadContext ctx = value.getRuntime().getCurrentContext();
+
         if (value.isNil()) {
 
             jgen.writeNull(); // for RubyNil and NullObjects
 
+        } else if (value instanceof JavaProxy) {
+
+            provider.defaultSerializeValue(((JavaProxy) value).getObject(), jgen);
+
         } else if (value instanceof RubyString) {
 
-            jgen.writeString(value.toString());
+            RubyUtils.writeBytes(value, jgen);
 
         } else if (value instanceof RubySymbol) {
-
-            jgen.writeString(value.toString());
+//            jgen.writeString(value.toString());
+            RubyString s = ((RubySymbol) value).asString();
+            jgen.writeUTF8String(s.getBytes(), 0, s.size());
 
         } else if (value instanceof RubyBoolean) {
 
@@ -127,34 +140,79 @@ public class RubyAnySerializer extends StdSerializer<IRubyObject> {
 
         } else if (value instanceof RubyHash) {
 
-            provider.findTypedValueSerializer(value.getJavaClass(), true, null).serialize(value, jgen, provider);
+            serializeHash(value, jgen, provider);
 
         } else if (value instanceof RubyArray) {
 
-            provider.findTypedValueSerializer(value.getJavaClass(), true, null).serialize(value, jgen, provider);
+            serializeArray(value, jgen, provider);
 
         } else if (value instanceof RubyStruct) {
 
-            IRubyObject obj = value.callMethod(ctx, "to_a");
-            provider.findTypedValueSerializer(obj.getJavaClass(), true, null).serialize(obj, jgen, provider);
+            IRubyObject obj = value.callMethod(value.getRuntime().getCurrentContext(), "to_a");
+            serializeArray(obj, jgen, provider);
+
+        } else if (value instanceof RubyTime) {
+//            System.err.println("------->>>> RubyTime");
+            serializeTime((RubyTime) value, jgen, provider);
 
         } else {
 
-            Class<?> cls = rubyJavaClassLookup(value.getClass());
-            if (cls != null) {
-                Object val = value.toJava(cls);
-                if (val != null) {
-                    provider.defaultSerializeValue(val, jgen);
-                } else {
-                    serializeUnknownRubyObject(ctx, value, jgen, provider);
-                }
-            } else {
-                serializeUnknownRubyObject(ctx, value, jgen, provider);
-            }
+            serializeUnknownRubyObject(value.getRuntime().getCurrentContext(), value, jgen, provider);
+
+        }
+    }
+
+    private void serializeArray(IRubyObject value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException {
+//            System.err.println("----->> RubyArray");
+
+        RubyArray arr = (RubyArray) value;
+        IRubyObject[] a = arr.toJavaArray();
+        jgen.writeStartArray();
+        for (IRubyObject val : a) {
+            serialize(val, jgen, provider);
+        }
+        jgen.writeEndArray();
+    }
 
+    private void serializeHash(IRubyObject value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException {
+//            System.err.println("----->> RubyHash");
+
+        RubyHash h = (RubyHash) value;
+        jgen.writeStartObject();
+        for (Object o : h.directEntrySet()) {
+            RubyHash.RubyHashEntry next = (RubyHash.RubyHashEntry) o;
+            serializeKey((IRubyObject) next.getKey(), jgen, provider);
+            serialize((IRubyObject) next.getValue(), jgen, provider);
+        }
+        jgen.writeEndObject();
+    }
+
+    private void serializeTime(RubyTime dt, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException {
+        DateFormat df = provider.getConfig().getDateFormat();
+        if (df == null) {
+            // DateFormat should always be set
+            provider.defaultSerializeDateValue(dt.getJavaDate(), jgen);
+        } else if (df instanceof RubyDateFormat) {
+            // why another branch? I thought there was an easy win on to_s
+            // maybe with jruby 9000
+            RubyDateFormat rdf = (RubyDateFormat) df.clone();
+            jgen.writeString(rdf.format(dt.getJavaDate()));
+        } else {
+            SimpleDateFormat sdf = (SimpleDateFormat) df.clone();
+            jgen.writeString(df.format(dt.getJavaDate()));
         }
     }
 
+    private void serializeKey(IRubyObject key, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException {
+
+        jgen.writeFieldName(key.asJavaString());
+
+    }
+
     /**
      * Default implementation will write type prefix, call regular serialization method (since assumption is that value itself does not need JSON Array or Object start/end markers), and then write type suffix. This should work for most cases; some sub-classes may want to change this behavior.
      *
@@ -165,7 +223,6 @@ public class RubyAnySerializer extends StdSerializer<IRubyObject> {
      * @throws java.io.IOException
      * @throws com.fasterxml.jackson.core.JsonGenerationException
      */
-    @Override
     public void serializeWithType(IRubyObject value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
             throws IOException, JsonGenerationException {
         typeSer.writeTypePrefixForScalar(value, jgen);

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

@@ -0,0 +1,18 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class RubyBigDecimalValueConverter implements RubyConverter {
+
+    @Override
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
+        return RubyUtils.rubyBigDecimal(ruby, jp.getDecimalValue());
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class RubyBigIntValueConverter implements RubyConverter {
+
+    @Override
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
+        if (jp.getNumberType() == JsonParser.NumberType.BIG_INTEGER) {
+            return RubyUtils.rubyBignum(ruby, jp.getBigIntegerValue());
+        }
+        return RubyUtils.rubyFixnum(ruby, jp.getLongValue());
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.*;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public interface RubyConverter {
+
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException;
+}