jrjackson 0.3.9-java

data/src/main/java/com/jrjackson/RubyIntValueConverter.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 RubyIntValueConverter implements RubyConverter {
+
+    @Override
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
+        return RubyUtils.rubyFixnum(ruby, jp.getLongValue());
+    }
+}

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

@@ -0,0 +1,72 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.Version;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ser.DefaultSerializerProvider;
+import com.fasterxml.jackson.module.afterburner.AfterburnerModule;
+import java.text.SimpleDateFormat;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class RubyJacksonModule extends SimpleModule {
+
+    private static final SimpleDateFormat RDF = new RubyDateFormat("yyyy-MM-dd HH:mm:ss Z");
+
+    private static final ObjectMapper static_mapper = new ObjectMapper();
+    public static final JsonFactory factory = new JsonFactory(static_mapper).disable(JsonFactory.Feature.FAIL_ON_SYMBOL_HASH_OVERFLOW);
+
+    static {
+        static_mapper.registerModule(new RubyJacksonModule().addSerializer(
+                IRubyObject.class, RubyAnySerializer.instance
+        ));
+        static_mapper.registerModule(new AfterburnerModule());
+        static_mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+    }
+
+    private RubyJacksonModule() {
+        super("JrJacksonStrModule", new Version(1, 2, 18, "0", "com.jrjackson.jruby", "jrjackson"));
+    }
+
+    public static ObjectMapper mapperWith(Ruby ruby, RubyKeyConverter nameConverter,
+            RubyConverter intConverter, RubyConverter floatConverter) {
+
+        return static_mapper.copy().registerModule(
+                new RubyJacksonModule().addDeserializer(
+                        Object.class,
+                        new RubyObjectDeserializer().with(ruby, nameConverter, intConverter, floatConverter)
+                )
+        );
+    }
+
+    public static ObjectMapper rawMapper() {
+        return static_mapper;
+    }
+
+    public static DefaultSerializerProvider createProvider(SimpleDateFormat sdf) {
+        static_mapper.setDateFormat(sdf);
+        return ((DefaultSerializerProvider) static_mapper.getSerializerProvider()).createInstance(
+                static_mapper.getSerializationConfig(),
+                static_mapper.getSerializerFactory()
+        );
+    }
+
+    public static DefaultSerializerProvider createProvider() {
+        static_mapper.setDateFormat(RDF);
+        return ((DefaultSerializerProvider) static_mapper.getSerializerProvider()).createInstance(
+                static_mapper.getSerializationConfig(),
+                static_mapper.getSerializerFactory()
+        );
+    }
+
+    public static ObjectMapper rawBigNumberMapper() {
+        static_mapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
+        static_mapper.enable(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS);
+        return static_mapper;
+    }
+
+}

data/src/main/java/com/jrjackson/RubyKeyConverter.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 RubyKeyConverter {
+
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException;
+}

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

@@ -0,0 +1,9 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public interface RubyNameConverter {
+
+    public RubyObject convert(Ruby ruby, String name);
+}

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

@@ -0,0 +1,182 @@
+package com.jrjackson;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.*;
+
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.util.ObjectBuffer;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+
+
+public class RubyObjectDeserializer
+        extends StdDeserializer<RubyObject> {
+
+    private static final long serialVersionUID = 1L;
+
+    private Ruby _ruby;
+
+    private RubyKeyConverter _key_converter;
+    private RubyConverter _int_converter;
+    private RubyConverter _float_converter;
+    final private RubyStringConverter _str_converter = new RubyStringConverter();
+
+    public RubyObjectDeserializer() {
+        super(RubyObject.class);
+    }
+
+    public RubyObjectDeserializer with(Ruby ruby, RubyKeyConverter nameConv,
+            RubyConverter intConv, RubyConverter floatConv) {
+        _ruby = ruby;
+        _key_converter = nameConv;
+        _int_converter = intConv;
+        _float_converter = floatConv;
+        return this;
+    }
+
+    /**
+     * /**********************************************************
+     * /* Deserializer API /**********************************************************
+     * @param jp
+     * @param ctxt
+     * @return 
+     * @throws java.io.IOException
+     * @throws com.fasterxml.jackson.core.JsonProcessingException
+     */
+    
+    @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 _key_converter.convert(_ruby, jp);
+
+            case VALUE_EMBEDDED_OBJECT:
+                return RubyUtils.rubyObject(_ruby, jp.getEmbeddedObject());
+
+            case VALUE_STRING:
+                return _str_converter.convert(_ruby, jp);
+
+            case VALUE_NUMBER_INT:
+                /* [JACKSON-100]: caller may want to get all integral values
+                 * returned as BigInteger, for consistency
+                 */
+                return _int_converter.convert(_ruby, jp);
+
+            case VALUE_NUMBER_FLOAT:
+                return _float_converter.convert(_ruby, jp);
+
+            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 (RubyObject) _ruby.getNil();
+
+            case END_ARRAY: // invalid
+            case END_OBJECT: // invalid
+            default:
+                throw ctxt.mappingException(Object.class);
+        }
+    }
+
+    /**
+     * /**********************************************************
+     * /* Internal methods /**********************************************************
+     */
+    /**
+     * Method called to map a JSON Array into a Java value.
+     * @param jp
+     * @param ctxt
+     * @return RubyObject
+     * @throws java.io.IOException 
+     * @throws com.fasterxml.jackson.core.JsonProcessingException 
+     */
+    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;
+    }
+
+    /**
+     * Method called to map a JSON Object into a Java value.
+     * @param jp
+     * @param ctxt
+     * @return RubyObject
+     * @throws java.io.IOException 
+     * @throws com.fasterxml.jackson.core.JsonProcessingException 
+     */
+    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);
+        }
+
+        RubyObject field1 = _key_converter.convert(_ruby, jp);
+        jp.nextToken();
+        RubyObject value1 = deserialize(jp, ctxt);
+        
+        if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable
+            return RubyUtils.rubyHash(_ruby, field1, value1);
+        }
+
+        RubyObject field2 = _key_converter.convert(_ruby, jp);
+        jp.nextToken();
+        
+        RubyHash result =  RubyUtils.rubyHash(_ruby, field1, value1, field2, deserialize(jp, ctxt));
+        
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            return  result;
+        }
+
+        // And then the general case; default map size is 16
+        do {
+            RubyObject fieldName = _key_converter.convert(_ruby, jp);
+            jp.nextToken();
+            result.fastASetCheckString(_ruby, fieldName, deserialize(jp, ctxt));
+        } while (jp.nextToken() != JsonToken.END_OBJECT);
+        return result;
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.*;
+
+import java.io.IOException;
+import java.nio.CharBuffer;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public class RubyStringConverter implements RubyConverter {
+
+    @Override
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
+        return RubyUtils.rubyString(ruby, 
+            CharBuffer.wrap(jp.getTextCharacters(), 0, jp.getTextLength())
+        );
+    }
+}

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

@@ -0,0 +1,15 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.*;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public class RubyStringKeyConverter implements RubyKeyConverter {
+
+    @Override
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
+        return RubyUtils.rubyString(ruby, jp.getCurrentName());
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public class RubyStringNameConverter implements RubyNameConverter {
+
+    @Override
+    public RubyObject convert(Ruby ruby, String name){
+        return RubyUtils.rubyString(ruby, name);
+    }
+}

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

@@ -0,0 +1,15 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.*;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public class RubySymbolKeyConverter implements RubyKeyConverter {
+    
+    @Override
+    public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
+        return RubyUtils.rubySymbol(ruby, jp.getCurrentName());
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+
+public class RubySymbolNameConverter implements RubyNameConverter {
+    
+    @Override
+    public RubyObject convert(Ruby ruby, String s) {
+        return RubyUtils.rubySymbol(ruby, s);
+    }
+}

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

@@ -0,0 +1,150 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import java.io.IOException;
+import java.util.*;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyHash;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.ext.bigdecimal.RubyBigDecimal;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.SafeDoubleParser;
+
+public class RubyUtils {
+
+    private final static DateTimeFormatter FORMATTER = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss Z").withLocale(Locale.ENGLISH);
+    private final static DateTimeFormatter UTC_FORMATTER = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss 'UTC'").withLocale(Locale.ENGLISH);
+
+    public static RubyObject rubyObject(Ruby ruby, Object node) {
+        return (RubyObject) JavaUtil.convertJavaToRuby(ruby, node);
+    }
+
+    public static RubyString rubyString(Ruby ruby, String node) {
+        return RubyString.newUnicodeString(ruby, node);
+    }
+
+    public static RubyString rubyString(Ruby ruby, byte[] node) {
+        return RubyString.newString(ruby, node);
+    }
+
+    public static RubyString rubyString(Ruby ruby, CharSequence node) {
+        return RubyString.newUnicodeString(ruby, node);
+    }
+
+    public static RubySymbol rubySymbol(Ruby ruby, String node) {
+        return RubySymbol.newSymbol(ruby, node);
+    }
+
+    public static RubyArray rubyArray(Ruby ruby, Object[] arg) {
+        return (RubyArray) JavaUtil.convertJavaToRuby(ruby, arg);
+    }
+
+    public static RubyArray rubyArray(Ruby ruby, List arg) {
+        return (RubyArray) JavaUtil.convertJavaToRuby(ruby, arg);
+    }
+
+    public static RubyHash rubyHash(Ruby ruby, Map arg) {
+        return (RubyHash) JavaUtil.convertJavaToRuby(ruby, arg);
+    }
+
+    public static RubyFixnum rubyFixnum(Ruby ruby, int arg) {
+        return ruby.newFixnum(arg);
+    }
+
+    public static RubyFixnum rubyFixnum(Ruby ruby, long arg) {
+        return ruby.newFixnum(arg);
+    }
+
+    public static RubyBignum rubyBignum(Ruby ruby, BigInteger arg) {
+        return RubyBignum.newBignum(ruby, arg);
+    }
+
+    public static RubyFloat rubyFloat(Ruby ruby, double arg) {
+        return ruby.newFloat(arg);
+    }
+
+    public static RubyFloat rubyFloat(Ruby ruby, String arg) {
+        double d = SafeDoubleParser.parseDouble(arg);
+        return ruby.newFloat(d);
+    }
+
+    public static RubyBigDecimal rubyBigDecimal(Ruby ruby, BigDecimal arg) {
+        return new RubyBigDecimal(ruby, arg);
+    }
+
+    public static RubyBoolean rubyBoolean(Ruby ruby, Boolean arg) {
+        return ruby.newBoolean(arg);
+    }
+
+    public static RubyHash rubyHash(Ruby ruby, IRubyObject key, IRubyObject value) {
+        RubyHash hash = RubyHash.newHash(ruby);
+        hash.fastASet(key, value);
+        return hash;
+    }
+
+    public static RubyHash rubyHash(Ruby ruby, IRubyObject key1, IRubyObject value1,
+                                      IRubyObject key2, IRubyObject value2) {
+        RubyHash hash = rubyHash(ruby, key1, value1);
+        hash.fastASet(key2, value2);
+        return hash;
+    }
+
+    public static String jodaTimeString(DateTime dt) {
+        // copied from the RubyTime to_s method
+        // to prevent the double handling of a String -> RubyString -> String
+        DateTimeFormatter simpleDateFormat;
+        if (dt.getZone() == DateTimeZone.UTC) {
+            simpleDateFormat = UTC_FORMATTER;
+        } else {
+            simpleDateFormat = FORMATTER;
+        }
+
+        return simpleDateFormat.print(dt);
+
+        // JrJackson: no access to private boolean isTzRelative
+
+//        String result = simpleDateFormat.print(dt);
+//
+//        if (isTzRelative) {
+//            // display format needs to invert the UTC offset if this object was
+//            // created with a specific offset in the 7-arg form of #new
+//            DateTimeZone dtz = dt.getZone();
+//            int offset = dtz.toTimeZone().getOffset(dt.getMillis());
+//            DateTimeZone invertedDTZ = DateTimeZone.forOffsetMillis(offset);
+//            DateTime invertedDT = dt.withZone(invertedDTZ);
+//            result = simpleDateFormat.print(invertedDT);
+//        }
+//
+//        return result;
+    }
+
+
+    public static void writeBytes(IRubyObject value, JsonGenerator jgen)
+        throws IOException {
+//            jgen.writeString(value.toString());
+//            byte[] b = s.getBytes();
+//            jgen.writeUTF8String(b, 0, b.length);
+//            jgen.writeUTF8String(s.getBytes(), 0, s.size());
+            RubyString s = (RubyString)value;
+            ByteList b = s.getByteList();
+            jgen.writeUTF8String(b.unsafeBytes(), b.begin(), b.length());
+    }
+}