jrjackson 0.3.9-java

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

@@ -0,0 +1,108 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+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.databind.DeserializationFeature;
+import org.jruby.exceptions.RaiseException;
+
+
+@JRubyModule(name = "JrJacksonRaw")
+public class JrJacksonRaw extends JrJacksonBase {
+
+    public JrJacksonRaw(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 IOException {
+        Ruby _ruby = context.runtime;
+        RubyHash options = null;
+
+        if (opts != context.nil) {
+            options = opts.convertToHash();
+
+            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 {
+            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, 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, 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, RaiseException {
+
+        return direct(context, self, arg, false, true, false, false);
+
+    }
+}

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

@@ -0,0 +1,89 @@
+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);
+    }
+
+    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().disable(JsonFactory.Feature.FAIL_ON_SYMBOL_HASH_OVERFLOW);
+        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

@@ -0,0 +1,38 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class JrJacksonService implements BasicLibraryService {
+
+    @Override
+    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;
+        }
+    }
+}