jrjackson 0.2.9 → 0.3.0

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

@@ -0,0 +1,147 @@
+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.ArrayList;
+import java.util.HashMap;
+
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class JjParse {
+    private final JavaHandler _handler;
+    protected final HashMap<JsonStreamContext, Object> _objectMap = new HashMap<JsonStreamContext, Object>();
+    protected JsonStreamContext _deepestContext;
+
+    public JjParse(JavaHandler 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();
+        Object dtarget = _objectMap.get(_deepestContext);
+
+        if (px == null) {
+            _handler.addValue(dtarget);
+            return;
+        }
+
+        Object value = _objectMap.get(x);
+
+        if (x.inArray()) {
+            _handler.arrayAppend(
+                    (ArrayList<Object>)value, dtarget);
+        } else if (x.inObject()) {
+            _handler.hashSet(
+                    (HashMap<String, Object>)value, callHashKey(x), dtarget);
+
+        } else {
+            _handler.addValue(value);
+        }
+    }
+
+    private void callAddValue(JsonStreamContext x, Object val) {
+
+        if (x.inArray()) {
+            ArrayList<Object> a = (ArrayList<Object>)_objectMap.get(x);
+            _handler.arrayAppend(a, val);
+        } else if (x.inObject()) {
+            HashMap<String, Object> h = (HashMap<String, Object>)_objectMap.get(x);
+            _handler.hashSet(h, callHashKey(x), val);
+
+        } else {
+            _handler.addValue(val);
+        }
+    }
+
+    private String callHashKey(JsonStreamContext x) {
+        String k = x.getCurrentName();
+        if (k == null) {
+            return null;
+        }
+        return (String)_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/JrJacksonBase.java

@@ -0,0 +1,159 @@
+/*
+ * 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 com.fasterxml.jackson.core.JsonEncoding;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.ByteArrayOutputStream;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.stringio.StringIO;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+import org.jcodings.specific.UTF8Encoding;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubySymbol;
+import org.jruby.util.ByteList;
+
+/**
+ *
+ * @author guy
+ */
+public class JrJacksonBase extends RubyObject {
+
+    private static final SimpleDateFormat RDF = new RubyDateFormat("yyyy-MM-dd HH:mm:ss Z");
+
+    // serialize
+    @JRubyMethod(module = true, name = {"generate", "dump"}, required = 1, optional = 1)
+    public static IRubyObject generate(ThreadContext context, IRubyObject self, IRubyObject[] args)
+            throws IOException, RaiseException {
+        Ruby _ruby = context.runtime;
+        RubyHash options = (args.length <= 1) ? RubyHash.newHash(_ruby) : args[1].convertToHash();
+        String format = (String) options.get(RubyUtils.rubySymbol(_ruby, "date_format"));
+
+//        StringWriter out = new StringWriter();
+//        JsonGenerator jgen = RubyJacksonModule.factory.createGenerator(out);
+
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        JsonGenerator jgen = RubyJacksonModule.factory.createGenerator(
+                baos, JsonEncoding.UTF8);
+
+        if (flagged(options, RubyUtils.rubySymbol(_ruby, "pretty"))) {
+            jgen.useDefaultPrettyPrinter();
+        }
+
+        SimpleDateFormat simpleFormat;
+        if (format != null) {
+            simpleFormat = new SimpleDateFormat(format);
+            String timezone = (String) options.get(RubyUtils.rubySymbol(_ruby, "timezone"));
+            if (timezone != null) {
+                simpleFormat.setTimeZone(TimeZone.getTimeZone(timezone));
+            }
+        } else {
+            // using a 'marker' class instance, will not use later but default to #to_s
+            simpleFormat = RDF;
+        }
+
+        try {
+            RubyAnySerializer.instance.serialize(args[0], jgen,
+                    RubyJacksonModule.createProvider(simpleFormat));
+            jgen.close();
+            ByteList bl = new ByteList(baos.toByteArray(),
+                    UTF8Encoding.INSTANCE);
+            return RubyString.newString(_ruby, bl);
+//            return RubyUtils.rubyString(_ruby, out.toString());
+        } catch (JsonProcessingException e) {
+            throw ParseError.newParseError(_ruby, e.getLocalizedMessage());
+        }
+    }
+
+    protected static boolean flagged(RubyHash opts, RubySymbol key) {
+        Object val = opts.get(key);
+        if (val == null) {
+            return false;
+        }
+        boolean flag = (Boolean) val;
+        return flag;
+    }
+
+    protected static boolean flagged(RubyHash opts, RubySymbol key, boolean returnVal) {
+        if(!opts.containsKey(key)) {
+            return returnVal;
+        }
+        Object val = opts.get(key);
+        if (val == null) {
+            return returnVal;
+        }
+        boolean flag = (Boolean) val;
+        return flag;
+    }
+
+    protected static IRubyObject _sjcparse(ThreadContext context, IRubyObject handler, IRubyObject arg, IRubyObject opts, StreamParse sp) throws RaiseException {
+
+        JsonParser jp;
+        try {
+            jp = buildParser(context, RubyJacksonModule.factory, arg);
+        } catch (IOException e) {
+            throw context.runtime.newIOError(e.getLocalizedMessage());
+        }
+        return sp.deserialize(jp);
+    }
+
+    protected static JsonParser buildParser(ThreadContext ctx, JsonFactory jf, IRubyObject arg) throws IOException {
+        if (arg instanceof RubyString) {
+            return jf.createParser(((RubyString) arg).getByteList().bytes());
+        } else if (arg instanceof StringIO) {
+            RubyString content = (RubyString) ((StringIO) arg).string(ctx);
+            return jf.createParser(content.getByteList().bytes());
+        } else {
+            // must be an IO object then
+            return jf.createParser(((RubyIO) arg).getInStream());
+        }
+    }
+
+    protected static IRubyObject _parse(ThreadContext context, IRubyObject arg, ObjectMapper mapper) throws IOException, RaiseException {
+        Ruby ruby = context.runtime;
+        // same format as Ruby Time #to_s
+        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
+        mapper.setDateFormat(simpleFormat);
+        try {
+            Object o;
+            if (arg instanceof RubyString) {
+                o = mapper.readValue(((RubyString) arg).getByteList().bytes(), Object.class);
+            } else if (arg instanceof StringIO) {
+                RubyString content = (RubyString) ((StringIO) arg).string(context);
+                o = mapper.readValue(content.getByteList().bytes(), Object.class);
+            } else {
+                // must be an IO object then
+                o = mapper.readValue(((RubyIO) arg).getInStream(), Object.class);
+            }
+            return RubyUtils.rubyObject(ruby, o);
+        } catch (JsonProcessingException e) {
+            throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+        } catch (IOException e) {
+            throw ruby.newIOError(e.getLocalizedMessage());
+        }
+    }
+
+    public JrJacksonBase(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+}

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

@@ -0,0 +1,81 @@
+package com.jrjackson;
+
+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.core.JsonProcessingException;
+import org.jruby.RubyHash;
+import org.jruby.exceptions.RaiseException;
+
+
+@JRubyModule(name = "JrJacksonJava")
+public class JrJacksonJava extends JrJacksonBase {
+
+    public JrJacksonJava(Ruby ruby, RubyClass metaclass) {
+        super(ruby, metaclass);
+    }
+
+    // deserialize
+    @JRubyMethod(module = true, name = {"parse", "load"}, required = 2)
+    public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject arg, IRubyObject opts)
+            throws JsonProcessingException, IOException, RaiseException {
+
+        JavaConverter ikonv = new JavaBigIntValueConverter();
+        JavaConverter dkonv = new JavaBigDecimalValueConverter();
+        if (opts != context.nil) {
+            RubyHash options = opts.convertToHash();
+            if (options.size() > 0) {
+                if (!flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "use_bigdecimal"), true)) {
+                    dkonv = new JavaFloatValueConverter();
+                }
+                if (flagged(options,
+                        RubyUtils.rubySymbol(context.runtime, "use_smallint"))) {
+                    ikonv = new JavaLongValueConverter();
+                }
+            }
+        }
+
+        JavaHandler handler = new JavaHandler(ikonv, dkonv);
+        JjParse parse = new JjParse(handler);
+        JsonParser jp;
+        try {
+            jp = buildParser(context, RubyJacksonModule.factory, arg);
+        } catch (IOException e) {
+            throw context.runtime.newIOError(e.getLocalizedMessage());
+        }
+
+        parse.deserialize(jp);
+        jp.close();
+        return RubyUtils.rubyObject(context.runtime, handler.getResult());
+    }
+
+    // deserialize
+    @JRubyMethod(module = true, name = {"parse_raw", "load_raw"}, required = 2)
+    public static IRubyObject parse_raw(ThreadContext context, IRubyObject self, IRubyObject arg, IRubyObject opts)
+            throws JsonProcessingException, IOException, RaiseException {
+
+        JavaConverter ikonv = new JavaBigIntValueConverter();
+        JavaConverter dkonv = new JavaBigDecimalValueConverter();
+
+        JavaHandler handler = new JavaHandler(ikonv, dkonv);
+        JjParse parse = new JjParse(handler);
+        JsonParser jp;
+        try {
+            jp = buildParser(context, RubyJacksonModule.factory, arg);
+        } catch (IOException e) {
+            throw context.runtime.newIOError(e.getLocalizedMessage());
+        }
+
+        parse.deserialize(jp);
+        jp.close();
+        return RubyUtils.rubyObject(context.runtime, handler.getResult());
+    }
+}

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

@@ -2,150 +2,107 @@ package com.jrjackson;
 
 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.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.ext.stringio.StringIO;
 
 import java.io.IOException;
 
-import java.text.SimpleDateFormat;
-import java.util.TimeZone;
-
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.core.JsonProcessingException;
+import org.jruby.exceptions.RaiseException;
 
 
 @JRubyModule(name = "JrJacksonRaw")
-public class JrJacksonRaw extends RubyObject {
+public class JrJacksonRaw extends JrJacksonBase {
 
     public JrJacksonRaw(Ruby ruby, RubyClass metaclass) {
         super(ruby, metaclass);
     }
 
-    private static boolean flagged(RubyHash opts, RubySymbol key) {
-        Object val = opts.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;
-        ObjectMapper local = null;
         Ruby _ruby = context.runtime;
+        RubyHash options = null;
 
         if (opts != context.nil) {
             options = opts.convertToHash();
-            if (flagged(options, RubyUtils.rubySymbol(_ruby, "symbolize_keys"))) {
-                local = RubyJacksonModule.mappedAs("sym", _ruby);
-            }
-            if (flagged(options, RubyUtils.rubySymbol(_ruby, "raw"))) {
-                local = RubyJacksonModule.mappedAs("raw", _ruby);
-            }
-            if (local == null) {
-                local = RubyJacksonModule.mappedAs("str", _ruby);
-            }
-            if (flagged(options, RubyUtils.rubySymbol(_ruby, "use_bigdecimal"))) {
-                local.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
-            } else {
-                local.disable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
-            }
+
+            return direct(context, self, arg,
+                    flagged(options, RubyUtils.rubySymbol(_ruby, "use_bigdecimal")),
+                    !flagged(options, RubyUtils.rubySymbol(_ruby, "use_smallint")),
+                    flagged(options, RubyUtils.rubySymbol(_ruby, "symbolize_keys")),
+                    flagged(options, RubyUtils.rubySymbol(_ruby, "raw")));
+
         } else {
-            local = RubyJacksonModule.mappedAs("str", _ruby);
+            return direct(context, self, arg, false, true, false, false);
+        }
+    }
+
+    private static IRubyObject direct(ThreadContext context, IRubyObject self, IRubyObject arg,
+            boolean use_big_decimal, boolean use_big_int,
+            boolean use_symbols, boolean use_raw) throws IOException {
+        ObjectMapper local = RubyJacksonModule.rawBigNumberMapper();
+
+        RubyConverter vci = new RubyIntValueConverter();
+        RubyConverter vcf = new RubyFloatValueConverter();
+        RubyKeyConverter kcn;
+
+        if (use_big_decimal) {
+            vcf = new RubyBigDecimalValueConverter();
+        } else {
+            local.disable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
+        }
+
+        if (use_big_int) {
+            vci = new RubyBigIntValueConverter();
+        } else {
+            local.disable(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS);
+        }
+
+        if(use_raw) {
+            return _parse(context, arg, local);
         }
+
+        if (use_symbols) {
+            kcn = new RubySymbolKeyConverter();
+        } else {
+            kcn = new RubyStringKeyConverter();
+        }
+
+        local = RubyJacksonModule.mapperWith(context.runtime, kcn, vci, vcf);
         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 {
-        ObjectMapper mapper = RubyJacksonModule.mappedAs("raw", context.runtime);
-        return _parse(context, arg, mapper);
+            throws IOException, RaiseException {
+        return direct(context, self, arg, false, false, false, true);
+    }
+
+    @JRubyMethod(module = true, name = {"parse_raw_bd", "load_raw_bd"}, required = 1)
+    public static IRubyObject parse_raw_bd(ThreadContext context, IRubyObject self, IRubyObject arg)
+            throws IOException, RaiseException {
+
+        return direct(context, self, arg, true, true, false, true);
     }
 
     @JRubyMethod(module = true, name = {"parse_sym", "load_sym"}, required = 1)
     public static IRubyObject parse_sym(ThreadContext context, IRubyObject self, IRubyObject arg)
-            throws IOException {
-        ObjectMapper mapper = RubyJacksonModule.mappedAs("sym", context.runtime);
-        return _parse(context, arg, mapper);
+            throws IOException, RaiseException {
+
+        return direct(context, self, arg, false, false, true, false);
     }
 
     @JRubyMethod(module = true, name = {"parse_str", "load_str"}, required = 1)
     public static IRubyObject parse_str(ThreadContext context, IRubyObject self, IRubyObject arg)
-            throws IOException {
-        ObjectMapper mapper = RubyJacksonModule.mappedAs("str", context.runtime);
-        return _parse(context, arg, mapper);
-    }
+            throws IOException, RaiseException {
 
-    private static IRubyObject _parse(ThreadContext context, IRubyObject arg, ObjectMapper mapper)
-            throws IOException {
-        Ruby ruby = context.runtime;
-        // same format as Ruby Time #to_s
-        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
-        mapper.setDateFormat(simpleFormat);
-        try {
-            Object o;
-            if (arg instanceof RubyString) {
-                o = mapper.readValue(
-                  ((RubyString) arg).getByteList().bytes(), Object.class
-                );
-            } else if (arg instanceof StringIO) {
-                RubyString content = (RubyString)((StringIO) arg).string(context);
-                o = mapper.readValue(
-                  content.getByteList().bytes(), Object.class
-                );
-            } else {
-                // must be an IO object then
-                o = mapper.readValue(((RubyIO)arg).getInStream(), Object.class);
-            }
-            return RubyUtils.rubyObject(ruby, o);
-        } catch (JsonProcessingException e) {
-            throw ParseError.newParseError(ruby, e.getLocalizedMessage());
-        } catch (IOException e) {
-            throw ruby.newIOError(e.getLocalizedMessage());
-        }
-    }
+        return direct(context, self, arg, false, true, false, false);
 
-    // serialize
-    @JRubyMethod(module = true, name = {"generate", "dump"}, required = 1, optional = 1)
-    public static IRubyObject generate(ThreadContext context, IRubyObject self, IRubyObject[] args)
-            throws IOException, JsonProcessingException {
-        Ruby _ruby = context.runtime;
-        Object obj = args[0].toJava(Object.class);
-        RubyHash options = (args.length <= 1) ? RubyHash.newHash(_ruby) : args[1].convertToHash();
-        String format = (String) options.get(RubyUtils.rubySymbol(_ruby, "date_format"));
-
-        ObjectMapper mapper = RubyJacksonModule.mappedAs("raw", _ruby);
-        // same format as Ruby Time #to_s
-        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
-
-        if (format != null) {
-            simpleFormat = new SimpleDateFormat(format);
-            String timezone = (String) options.get(RubyUtils.rubySymbol(_ruby, "timezone"));
-            if (timezone != null) {
-                simpleFormat.setTimeZone(TimeZone.getTimeZone(timezone));
-            }
-        }
-        mapper.setDateFormat(simpleFormat);
-        try {
-            String s = mapper.writeValueAsString(obj);
-            return RubyUtils.rubyString(_ruby, s);
-        } catch (JsonProcessingException e) {
-            throw ParseError.newParseError(_ruby, e.getLocalizedMessage());
-        } catch (IOException e) {
-            throw _ruby.newIOError(e.getLocalizedMessage());
-        }
     }
 }