jrjackson 0.0.7 → 0.1.0

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

@@ -0,0 +1,29 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class JrJacksonService implements BasicLibraryService {
+  public boolean basicLoad(final Ruby ruby) throws IOException {
+    RubyModule jr_jackson = ruby.defineModule("JrJackson");
+
+    RubyModule jr_jackson_str = ruby.defineModuleUnder("Str", jr_jackson);
+    jr_jackson_str.defineAnnotatedMethods(JrJacksonStr.class);
+
+    RubyModule jr_jackson_raw = ruby.defineModuleUnder("Raw", jr_jackson);
+    jr_jackson_raw.defineAnnotatedMethods(JrJacksonRaw.class);
+
+    RubyModule jr_jackson_sym = ruby.defineModuleUnder("Sym", jr_jackson);
+    jr_jackson_sym.defineAnnotatedMethods(JrJacksonSym.class);
+
+    RubyClass runtimeError = ruby.getRuntimeError();
+    RubyClass parseError = jr_jackson.defineClassUnder("ParseError", runtimeError, runtimeError.getAllocator());
+    return true;
+  }
+}

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

@@ -0,0 +1,80 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubyIO;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.stringio.RubyStringIO;
+import org.jruby.java.addons.IOJavaAddons;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.RubyDateFormat;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.util.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.core.Version;
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+@JRubyModule(name = "JrJacksonStr")
+public class JrJacksonStr extends RubyObject {
+  private static final ObjectMapper mapper = new ObjectMapper();
+  private static final SimpleModule module = new SimpleModule("JrJacksonStrModule");
+
+  static {
+    mapper.registerModule(module.addDeserializer(Object.class, RubyObjectDeserializer.instance));
+    mapper.setDateFormat(new RubyDateFormat("yyyy-MM-dd HH:mm:ss z", Locale.US, true));
+  }
+  
+  public JrJacksonStr(Ruby ruby, RubyClass metaclass) {
+    super(ruby, metaclass);
+  }
+
+  @JRubyMethod(module = true, name = {"parse", "load"}, required = 1)
+  public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject arg) {
+    Ruby ruby = context.getRuntime();
+    try {
+      Object o;
+      if (arg instanceof RubyString) {
+        o = mapper.readValue(arg.toString(), Object.class);
+      } else if ((arg instanceof RubyIO) || (arg instanceof RubyStringIO)) {
+        IRubyObject stream = IOJavaAddons.AnyIO.any_to_inputstream(context, arg);
+        o =  mapper.readValue((InputStream)stream.toJava(InputStream.class), Object.class);
+      } else {
+        throw ruby.newArgumentError("Unsupported source. This method accepts String or IO");
+      }
+      return (RubyObject)JavaUtil.convertJavaToRuby(ruby, o);
+    }
+    catch (JsonProcessingException e) {
+      throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+    }
+    catch (IOException e) {
+      throw ruby.newIOError(e.getLocalizedMessage());
+    }
+  }
+
+  @JRubyMethod(module = true, name = {"generate", "dump"}, required = 1)
+  public static IRubyObject generate(ThreadContext context, IRubyObject self, IRubyObject arg) {
+    Ruby ruby = context.getRuntime();
+    Object obj = arg.toJava(Object.class);
+    try {
+      String s = mapper.writeValueAsString(obj);
+      return ruby.newString(s);
+    }
+    catch (JsonProcessingException e) {
+      throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+    }
+    catch (IOException e) {
+      throw ruby.newIOError(e.getLocalizedMessage());
+    }
+  }
+}

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

@@ -0,0 +1,80 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubyIO;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.stringio.RubyStringIO;
+import org.jruby.java.addons.IOJavaAddons;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.RubyDateFormat;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.util.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.core.Version;
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+@JRubyModule(name = "JrJacksonSym")
+public class JrJacksonSym extends RubyObject {
+  private static final ObjectMapper mapper = new ObjectMapper();
+  private static final SimpleModule module = new SimpleModule("JrJacksonSymModule");
+
+  static {
+    mapper.registerModule(module.addDeserializer(Object.class, RubyObjectSymDeserializer.instance));
+    mapper.setDateFormat(new RubyDateFormat("yyyy-MM-dd HH:mm:ss z", Locale.US, true));
+  }
+
+  public JrJacksonSym(Ruby ruby, RubyClass metaclass) {
+    super(ruby, metaclass);
+  }
+
+  @JRubyMethod(module = true, name = {"parse", "load"}, required = 1)
+  public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject arg) {
+    Ruby ruby = context.getRuntime();
+    try {
+      Object o;
+      if (arg instanceof RubyString) {
+        o = mapper.readValue(arg.toString(), Object.class);
+      } else if ((arg instanceof RubyIO) || (arg instanceof RubyStringIO)) {
+        IRubyObject stream = IOJavaAddons.AnyIO.any_to_inputstream(context, arg);
+        o =  mapper.readValue((InputStream)stream.toJava(InputStream.class), Object.class);
+      } else {
+        throw ruby.newArgumentError("Unsupported source. This method accepts String or IO");
+      }
+      return (RubyObject)JavaUtil.convertJavaToRuby(ruby, o);
+    }
+    catch (JsonProcessingException e) {
+      throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+    }
+    catch (IOException e) {
+      throw ruby.newIOError(e.getLocalizedMessage());
+    }
+  }
+
+  @JRubyMethod(module = true, name = {"generate", "dump"}, required = 1)
+  public static IRubyObject generate(ThreadContext context, IRubyObject self, IRubyObject arg) {
+    Ruby ruby = context.getRuntime();
+    Object obj = arg.toJava(Object.class);
+    try {
+      String s = mapper.writeValueAsString(obj);
+      return ruby.newString(s);
+    }
+    catch (JsonProcessingException e) {
+      throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+    }
+    catch (IOException e) {
+      throw ruby.newIOError(e.getLocalizedMessage());
+    }
+  }
+}

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

@@ -0,0 +1,15 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.anno.JRubyClass;
+import org.jruby.exceptions.RaiseException;
+
+@JRubyClass(name = "JrJackson::ParseError", parent = "RuntimeError")
+public class ParseError {
+  public static RaiseException newParseError(Ruby ruby, String message) {
+    RubyClass errorClass = ruby.getModule("JrJackson").getClass("ParseError");
+    return new RaiseException(RubyException.newException(ruby, errorClass, message), true);
+  }
+}

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

@@ -0,0 +1,257 @@
+package com.jrjackson;
+
+import java.io.IOException;
+import java.util.*;
+
+import com.fasterxml.jackson.core.*;
+
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
+import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
+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;
+import org.jruby.RubyString;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+
+
+public class RubyObjectDeserializer
+    extends StdDeserializer<RubyObject>
+{
+    private static final long serialVersionUID = 1L;
+
+    private final static RubyObject[] NO_OBJECTS = new RubyObject[0];
+
+    protected final static Ruby __ruby__ = Ruby.getGlobalRuntime();
+
+    /**
+     * @since 2.2
+     */
+    public final static RubyObjectDeserializer instance = new RubyObjectDeserializer();
+    
+    public RubyObjectDeserializer() { super(RubyObject.class); }
+
+    /*
+    /**********************************************************
+    /* Deserializer API
+    /**********************************************************
+     */
+    
+    @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 mapObject(jp, ctxt);
+        case VALUE_EMBEDDED_OBJECT:
+            return toRuby(jp.getEmbeddedObject());
+        case VALUE_STRING:
+            return rubyString(jp);
+
+        case VALUE_NUMBER_INT:
+            /* [JACKSON-100]: caller may want to get all integral values
+             * returned as BigInteger, for consistency
+             */
+            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
+                return toRuby(jp.getBigIntegerValue()); // should be optimal, whatever it is
+            }
+            return toRuby(jp.getNumberValue()); // should be optimal, whatever it is
+
+        case VALUE_NUMBER_FLOAT:
+            /* [JACKSON-72]: need to allow overriding the behavior regarding
+             *   which type to use
+             */
+            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
+                return toRuby(jp.getDecimalValue());
+            }
+            return toRuby(Double.valueOf(jp.getDoubleValue()));
+
+        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 null;
+
+        case END_ARRAY: // invalid
+        case END_OBJECT: // invalid
+        default:
+            throw ctxt.mappingException(Object.class);
+        }
+    }
+
+    @Override
+    public RubyObject deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken t = jp.getCurrentToken();
+        switch (t) {
+        // First: does it look like we had type id wrapping of some kind?
+        case START_ARRAY:
+        case START_OBJECT:
+        case FIELD_NAME:
+            /* Output can be as JSON Object, Array or scalar: no way to know
+             * a this point:
+             */
+            return toRuby(typeDeserializer.deserializeTypedFromAny(jp, ctxt));
+
+        /* Otherwise we probably got a "native" type (ones that map
+         * naturally and thus do not need or use type ids)
+         */
+        case VALUE_STRING:
+            return rubyString(jp);
+
+        case VALUE_NUMBER_INT:
+            // For [JACKSON-100], see above:
+            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
+                return toRuby(jp.getBigIntegerValue());
+            }
+            /* and as per [JACKSON-839], allow "upgrade" to bigger types: out-of-range
+             * entries can not be produced without type, so this should "just work",
+             * even if it is bit unclean
+             */
+            return toRuby(jp.getNumberValue());
+
+        case VALUE_NUMBER_FLOAT:
+            // For [JACKSON-72], see above
+            if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
+                return toRuby(jp.getDecimalValue());
+            }
+            return __ruby__.newFloat(Double.valueOf(jp.getDoubleValue()));
+
+        case VALUE_TRUE:
+            return __ruby__.newBoolean(Boolean.TRUE);
+        case VALUE_FALSE:
+            return __ruby__.newBoolean(Boolean.FALSE);
+        case VALUE_EMBEDDED_OBJECT:
+            return toRuby(jp.getEmbeddedObject());
+
+        case VALUE_NULL: // should not get this far really but...
+            return null;
+        default:
+            throw ctxt.mappingException(Object.class);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    protected RubyObject toRuby(Object o) {
+      return (RubyObject)JavaUtil.convertJavaToRuby(__ruby__, o);
+    }
+
+    protected RubyString rubyString(JsonParser jp) throws IOException {
+      return __ruby__.newString(jp.getText());
+    }
+
+    /**
+     * Method called to map a JSON Array into a Java value.
+     */
+    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.
+     */
+    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__);
+        }
+        RubyString field1 = rubyString(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);
+        }
+        RubyString field2 = rubyString(jp);
+        jp.nextToken();
+        RubyObject value2 = deserialize(jp, ctxt);
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            return RuntimeHelpers.constructHash(__ruby__, field1, value1, field2, value2);
+        }
+        // And then the general case; default map size is 16
+        RubyHash result = RuntimeHelpers.constructHash(__ruby__, field1, value1, field2, value2);
+        do {
+            RubyString fieldName = rubyString(jp);
+            jp.nextToken();
+            result.fastASet(fieldName, deserialize(jp, ctxt));
+        } while (jp.nextToken() != JsonToken.END_OBJECT);
+        return result;
+    }
+
+    /**
+     * Method called to map a JSON Array into a Java Object array (Object[]).
+     */
+    // protected Object[] mapArrayToArray(JsonParser jp, DeserializationContext ctxt)
+    //     throws IOException, JsonProcessingException
+    // {
+    //     // Minor optimization to handle small lists (default size for ArrayList is 10)
+    //     if (jp.nextToken()  == JsonToken.END_ARRAY) {
+    //         return NO_OBJECTS;
+    //     }
+    //     ObjectBuffer buffer = ctxt.leaseObjectBuffer();
+    //     Object[] values = buffer.resetAndStart();
+    //     int ptr = 0;
+    //     do {
+    //         Object value = deserialize(jp, ctxt);
+    //         if (ptr >= values.length) {
+    //             values = buffer.appendCompletedChunk(values);
+    //             ptr = 0;
+    //         }
+    //         values[ptr++] = value;
+    //     } while (jp.nextToken() != JsonToken.END_ARRAY);
+    //     return buffer.completeAndClearBuffer(values, ptr);
+    // }
+}
+