jrjackson 0.2.9 → 0.3.0

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

@@ -0,0 +1,36 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.jrjackson;
+
+import java.text.DateFormatSymbols;
+import java.text.FieldPosition;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+/**
+ *
+ * @author guy
+ */
+public class RubyDateFormat extends SimpleDateFormat{
+
+    public RubyDateFormat() {
+    }
+
+    public RubyDateFormat(String pattern) {
+        super(pattern);
+    }
+
+    public RubyDateFormat(String pattern, Locale locale) {
+        super(pattern, locale);
+    }
+
+    public RubyDateFormat(String pattern, DateFormatSymbols formatSymbols) {
+
+        super(pattern, formatSymbols);
+    }
+
+}

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

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

@@ -0,0 +1,119 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class RubyHandler implements IParseHandler<IRubyObject, RubyArray, RubyHash> {
+
+    private final Ruby _ruby;
+    private final ThreadContext _ctx;
+    private final RubyNameConverter _keyConv;
+    private final RubyConverter _intConv;
+    private final RubyConverter _floatConv;
+    private final RubyConverter _strConv;
+    private IRubyObject _result;
+
+    public RubyHandler(ThreadContext ctx,
+            RubyNameConverter keyConverter,
+            RubyConverter intConverter,
+            RubyConverter floatConverter) {
+
+        _ctx = ctx;
+        _ruby = ctx.runtime;
+        _keyConv = keyConverter;
+        _intConv = intConverter;
+        _floatConv = floatConverter;
+        _strConv = new RubyStringConverter();
+    }
+
+    @Override
+    public void addValue(IRubyObject value) {
+
+        _result = value;
+    }
+
+    @Override
+    public IRubyObject hashStart() {
+        return RubyHash.newHash(_ruby);
+    }
+
+    @Override
+    public void hashEnd() {
+
+    }
+
+    @Override
+    public IRubyObject hashKey(String key) {
+        return _keyConv.convert(_ruby, key);
+    }
+
+    @Override
+    public void hashSet(RubyHash hash, IRubyObject key, IRubyObject value) {
+        hash.fastASet(key, value);
+    }
+
+    @Override
+    public IRubyObject arrayStart() {
+        return RubyArray.newArray(_ruby);
+    }
+
+    @Override
+    public void arrayEnd() {
+
+    }
+
+    @Override
+    public void arrayAppend(RubyArray array, IRubyObject value) {
+        array.append(value);
+    }
+
+    @Override
+    public IRubyObject treatNull() {
+        return _ctx.nil;
+    }
+
+    @Override
+    public IRubyObject treatInt(JsonParser jp) throws IOException {
+        return _intConv.convert(_ruby, jp);
+    }
+
+    @Override
+    public IRubyObject treatFloat(JsonParser jp) throws IOException {
+        return _floatConv.convert(_ruby, jp);
+    }
+
+    @Override
+    public IRubyObject treatString(JsonParser jp) throws IOException {
+        return _strConv.convert(_ruby, jp);
+    }
+
+    @Override
+    public IRubyObject trueValue() {
+        return _ruby.newBoolean(true);
+    }
+
+    @Override
+    public IRubyObject falseValue() {
+        return _ruby.newBoolean(false);
+    }
+
+    @Override
+    public IRubyObject getResult() {
+        return _result;
+    }
+
+    @Override
+    public void raiseError(String e) {
+        throw ParseError.newParseError(_ruby, e);
+    }
+
+}

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

@@ -1,20 +1,21 @@
 package com.jrjackson;
 
-
-import org.jruby.*;
-
+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.core.util.VersionUtil;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ser.DefaultSerializerProvider;
 import com.fasterxml.jackson.module.afterburner.AfterburnerModule;
-import org.jruby.runtime.builtin.IRubyObject;
+import java.text.SimpleDateFormat;
+
+import org.jruby.Ruby;
 
 public class RubyJacksonModule extends SimpleModule {
 
-    private static final ObjectMapper static_mapper = new ObjectMapper().registerModule(
-            new RubyJacksonModule().addSerializer(IRubyObject.class, RubyAnySerializer.instance)
-    );
+    private static final ObjectMapper static_mapper = new ObjectMapper();
+    public static final JsonFactory factory = new JsonFactory(static_mapper);
 
     static {
         static_mapper.registerModule(new AfterburnerModule());
@@ -22,44 +23,45 @@ public class RubyJacksonModule extends SimpleModule {
     }
 
     private RubyJacksonModule() {
-        super("JrJacksonStrModule", VersionUtil.versionFor(RubyJacksonModule.class));
+        super("JrJacksonStrModule", new Version(1, 2, 16, "0", "com.jrjackson.jruby", "jrjackson"));
     }
 
-    public static ObjectMapper mappedAs(String key, Ruby ruby) {
-        if ("raw".equals(key)) {
-            return static_mapper;
-        }
+    public static ObjectMapper mapperWith(Ruby ruby, RubyKeyConverter nameConverter,
+            RubyConverter intConverter, RubyConverter floatConverter){
 
-        ObjectMapper mapper = new ObjectMapper().registerModule(
-                new AfterburnerModule()
+        return static_mapper.copy().registerModule(
+            new RubyJacksonModule().addDeserializer(
+                Object.class,
+                new RubyObjectDeserializer().with(ruby, nameConverter, intConverter, floatConverter)
+            )
         );
+    }
 
-        if ("sym".equals(key)) {
-            mapper.registerModule(
-                    asSym(ruby)
-            );
-        } else {
-            mapper.registerModule(
-                    asStr(ruby)
-            );
-        }
-        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
-        return mapper;
+//    public static ObjectMapper rawMapper() {
+//        return static_mapper.registerModule(
+//            new RubyJacksonModule().addSerializer(
+//                IRubyObject.class, RubyAnySerializer.instance
+//            )
+//        );
+//    }
+
+    public static ObjectMapper rawMapper() {
+        return static_mapper;
     }
 
-    public static SimpleModule asSym(Ruby ruby) {
-        return new RubyJacksonModule().addSerializer(
-                IRubyObject.class, RubyAnySerializer.instance
-        ).addDeserializer(
-                Object.class, new RubyObjectDeserializer().withRuby(ruby).setSymbolStrategy()
+    public static DefaultSerializerProvider createProvider(SimpleDateFormat sdf) {
+        static_mapper.setDateFormat(sdf);
+        return ((DefaultSerializerProvider)static_mapper.getSerializerProvider()).createInstance(
+            static_mapper.getSerializationConfig(),
+            static_mapper.getSerializerFactory()
         );
     }
 
-    public static SimpleModule asStr(Ruby ruby) {
-        return new RubyJacksonModule().addSerializer(
-                IRubyObject.class, RubyAnySerializer.instance
-        ).addDeserializer(
-                Object.class, new RubyObjectDeserializer().withRuby(ruby).setStringStrategy()
-        );
+    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/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

@@ -5,7 +5,6 @@ import java.io.IOException;
 import com.fasterxml.jackson.core.*;
 
 import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.util.ObjectBuffer;
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
 
@@ -13,7 +12,7 @@ import org.jruby.Ruby;
 import org.jruby.RubyObject;
 import org.jruby.RubyArray;
 import org.jruby.RubyHash;
-import org.jruby.javasupport.util.RuntimeHelpers;
+
 
 public class RubyObjectDeserializer
         extends StdDeserializer<RubyObject> {
@@ -22,25 +21,21 @@ public class RubyObjectDeserializer
 
     private Ruby _ruby;
 
-    private RubyKeyConverter key_converter;
-    final private RubyStringConverter str_converter = new RubyStringConverter();
+    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 withRuby(Ruby ruby) {
+    public RubyObjectDeserializer with(Ruby ruby, RubyKeyConverter nameConv,
+            RubyConverter intConv, RubyConverter floatConv) {
         _ruby = ruby;
-        return this;
-    }
-
-    public RubyObjectDeserializer setStringStrategy() {
-        key_converter = str_converter;
-        return this;
-    }
-
-    public RubyObjectDeserializer setSymbolStrategy() {
-        key_converter = new RubySymbolConverter();
+        _key_converter = nameConv;
+        _int_converter = intConv;
+        _float_converter = floatConv;
         return this;
     }
 
@@ -57,6 +52,7 @@ public class RubyObjectDeserializer
     @Override
     public RubyObject deserialize(JsonParser jp, DeserializationContext ctxt)
             throws IOException, JsonProcessingException {
+        
         switch (jp.getCurrentToken()) {
             case START_OBJECT:
                 return mapObject(jp, ctxt);
@@ -65,29 +61,22 @@ public class RubyObjectDeserializer
                 return mapArray(jp, ctxt);
 
             case FIELD_NAME:
-                return key_converter.convert(_ruby, jp);
+                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);
+                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
                  */
-                JsonParser.NumberType numberType = jp.getNumberType();
-                if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS) || numberType == JsonParser.NumberType.BIG_INTEGER) {
-                    return RubyUtils.rubyBignum(_ruby, jp.getBigIntegerValue());
-                }
-                return RubyUtils.rubyFixnum(_ruby, jp.getLongValue());
+                return _int_converter.convert(_ruby, jp);
 
             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());
+                return _float_converter.convert(_ruby, jp);
 
             case VALUE_TRUE:
                 return _ruby.newBoolean(Boolean.TRUE);
@@ -165,24 +154,26 @@ public class RubyObjectDeserializer
             return RubyHash.newHash(_ruby);
         }
 
-        RubyObject field1 = key_converter.convert(_ruby, jp);
+        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 RuntimeHelpers.constructHash(_ruby, field1, value1);
+            return RubyUtils.rubyHash(_ruby, field1, value1);
         }
 
-        RubyObject field2 = key_converter.convert(_ruby, jp);
+        RubyObject field2 = _key_converter.convert(_ruby, jp);
         jp.nextToken();
-        RubyObject value2 = deserialize(jp, ctxt);
+        
+        RubyHash result =  RubyUtils.rubyHash(_ruby, field1, value1, field2, deserialize(jp, ctxt));
+        
         if (jp.nextToken() != JsonToken.FIELD_NAME) {
-            return RuntimeHelpers.constructHash(_ruby, field1, value1, field2, value2);
+            return  result;
         }
 
         // And then the general case; default map size is 16
-        RubyHash result = RuntimeHelpers.constructHash(_ruby, field1, value1, field2, value2);
         do {
-            RubyObject fieldName = key_converter.convert(_ruby, jp);
+            RubyObject fieldName = _key_converter.convert(_ruby, jp);
             jp.nextToken();
             result.fastASetCheckString(_ruby, fieldName, deserialize(jp, ctxt));
         } while (jp.nextToken() != JsonToken.END_OBJECT);

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

@@ -7,11 +7,10 @@ import java.nio.CharBuffer;
 import org.jruby.Ruby;
 import org.jruby.RubyObject;
 
-public class RubyStringConverter implements RubyKeyConverter {
+public class RubyStringConverter implements RubyConverter {
 
     @Override
     public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
-        // return RubyUtils.rubyString(ruby, jp.getText());
         return RubyUtils.rubyString(ruby, 
             CharBuffer.wrap(jp.getTextCharacters(), 0, jp.getTextLength())
         );

data/src/main/java/com/jrjackson/{RubySymbolConverter.java → RubyStringKeyConverter.java}

@@ -6,9 +6,10 @@ import java.io.IOException;
 import org.jruby.Ruby;
 import org.jruby.RubyObject;
 
-public class RubySymbolConverter implements RubyKeyConverter {
+public class RubyStringKeyConverter implements RubyKeyConverter {
 
+    @Override
     public RubyObject convert(Ruby ruby, JsonParser jp) throws IOException {
-        return RubyUtils.rubySymbol(ruby, jp.getText());
+        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

@@ -1,17 +1,31 @@
 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.*;
 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 {
@@ -80,6 +94,19 @@ public class RubyUtils {
         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
@@ -108,4 +135,16 @@ public class RubyUtils {
 //
 //        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(), 0, b.length());
+    }
 }