jrjackson 0.3.9-java

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

@@ -0,0 +1,17 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class JavaBigIntValueConverter implements JavaConverter {
+
+    @Override
+    public BigInteger convert(JsonParser jp) throws IOException {
+        return jp.getBigIntegerValue();
+    }
+}

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

@@ -0,0 +1,10 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.*;
+
+import java.io.IOException;
+
+public interface JavaConverter {
+
+    public Object convert(JsonParser jp) throws IOException;
+}

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

@@ -0,0 +1,16 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class JavaFloatValueConverter implements JavaConverter {
+
+    @Override
+    public Double convert(JsonParser jp) throws IOException {
+        return jp.getDoubleValue();
+    }
+}

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

@@ -0,0 +1,118 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+
+/**
+ *
+ * @author Guy Boertje
+ */
+
+/*
+ Long -> Integer
+ Double -> Float
+ JavaMath::BigDecimal -> BigDecimal
+ JavaMath::BigInteger -> Bignum
+ JavaUtil::ArrayList -> Array
+ JavaUtil::LinkedHashMap -> Hash
+ String -> String
+ */
+
+public class JavaHandler implements IParseHandler<Object, ArrayList<Object>, HashMap<String, Object>> {
+
+    private Object _result;
+    private final JavaConverter _intConv;
+    private final JavaConverter _floatConv;
+
+    public JavaHandler(
+            JavaConverter intConverter,
+            JavaConverter floatConverter) {
+
+        _intConv = intConverter;
+        _floatConv = floatConverter;
+
+    }
+
+    @Override
+    public void addValue(Object value) {
+        _result = value;
+    }
+
+    @Override
+    public Object hashStart() {
+        return new HashMap<String, Object>();
+    }
+
+    @Override
+    public void hashEnd() {
+
+    }
+
+    @Override
+    public Object hashKey(String key) {
+        return key;
+    }
+
+    @Override
+    public void hashSet(HashMap<String, Object> hash, Object key, Object value) {
+        hash.put((String)key, value);
+    }
+
+    @Override
+    public Object arrayStart() {
+        return new ArrayList<Object>();
+    }
+
+    @Override
+    public void arrayEnd() {
+
+    }
+
+    @Override
+    public void arrayAppend(ArrayList<Object> array, Object value) {
+        array.add(value);
+    }
+
+    @Override
+    public Object treatNull() {
+        return null;
+    }
+
+    @Override
+    public Object treatInt(JsonParser jp) throws IOException {
+        return _intConv.convert(jp);
+    }
+
+    @Override
+    public Object treatFloat(JsonParser jp) throws IOException {
+        return _floatConv.convert(jp);
+    }
+
+    @Override
+    public Object treatString(JsonParser jp) throws IOException {
+        return jp.getText();
+    }
+
+    @Override
+    public Object trueValue() {
+        return true;
+    }
+
+    @Override
+    public Object falseValue() {
+        return false;
+    }
+
+    @Override
+    public Object getResult() {
+        return _result;
+    }
+
+    @Override
+    public void raiseError(String e) {
+
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import java.io.IOException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class JavaLongValueConverter implements JavaConverter {
+
+    @Override
+    public Long convert(JsonParser jp) throws IOException {
+        return jp.getLongValue();
+    }
+}

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,152 @@
+/*
+ * 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 com.fasterxml.jackson.databind.SerializerProvider;
+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 {
+
+    // 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"));
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        JsonGenerator jgen = RubyJacksonModule.factory.createGenerator(
+                baos, JsonEncoding.UTF8);
+
+        if (flagged(options, RubyUtils.rubySymbol(_ruby, "pretty"))) {
+            jgen.useDefaultPrettyPrinter();
+        }
+
+        SerializerProvider provider;
+        if (format != null) {
+            SimpleDateFormat simpleFormat = new SimpleDateFormat(format);
+            String timezone = (String) options.get(RubyUtils.rubySymbol(_ruby, "timezone"));
+            if (timezone != null) {
+                simpleFormat.setTimeZone(TimeZone.getTimeZone(timezone));
+            }
+            provider = RubyJacksonModule.createProvider(simpleFormat);
+        } else {
+            provider = RubyJacksonModule.createProvider();
+        }
+
+        try {
+            RubyAnySerializer.instance.serialize(args[0], jgen, provider);
+            jgen.close();
+            ByteList bl = new ByteList(baos.toByteArray(),
+                    UTF8Encoding.INSTANCE);
+            return RubyString.newString(_ruby, bl);
+        } 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);
+    }
+
+}