json 1.4.6 → 1.5.0

data/ext/json/ext/parser/parser.h

@@ -13,6 +13,11 @@
 #else
 #define FORCE_UTF8(obj)
 #endif
+#ifdef HAVE_RUBY_ST_H
+#include "ruby/st.h"
+#else
+#include "st.h"
+#endif
 
 #define option_given_p(opts, key) RTEST(rb_funcall(opts, i_key_p, 1, key))
 
@@ -41,6 +46,8 @@ typedef struct JSON_ParserStruct {
     int symbolize_names;
     VALUE object_class;
     VALUE array_class;
+		int create_additions;
+		VALUE match_string;
 } JSON_Parser;
 
 #define GET_PARSER                          \

data/ext/json/ext/parser/parser.rl

@@ -77,7 +77,7 @@ static VALUE CNaN, CInfinity, CMinusInfinity;
 
 static ID i_json_creatable_p, i_json_create, i_create_id, i_create_additions,
           i_chr, i_max_nesting, i_allow_nan, i_symbolize_names, i_object_class,
-          i_array_class, i_key_p, i_deep_const_get;
+          i_array_class, i_key_p, i_deep_const_get, i_match, i_match_string;
 
 %%{
     machine JSON_common;
@@ -159,11 +159,11 @@ static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *resu
     %% write exec;
 
     if (cs >= JSON_object_first_final) {
-        if (RTEST(json->create_id)) {
+        if (json->create_additions) {
             VALUE klassname = rb_hash_aref(*result, json->create_id);
             if (!NIL_P(klassname)) {
                 VALUE klass = rb_funcall(mJSON, i_deep_const_get, 1, klassname);
-                if RTEST(rb_funcall(klass, i_json_creatable_p, 0)) {
+                if (RTEST(rb_funcall(klass, i_json_creatable_p, 0))) {
                     *result = rb_funcall(klass, i_json_create, 1, *result);
                 }
             }
@@ -457,28 +457,52 @@ static VALUE json_string_unescape(VALUE result, char *string, char *stringEnd)
     action parse_string {
         *result = json_string_unescape(*result, json->memo + 1, p);
         if (NIL_P(*result)) {
-			fhold;
-			fbreak;
-		} else {
-			FORCE_UTF8(*result);
-			fexec p + 1;
-		}
-	}
+            fhold;
+            fbreak;
+        } else {
+            FORCE_UTF8(*result);
+            fexec p + 1;
+        }
+    }
 
     action exit { fhold; fbreak; }
 
     main := '"' ((^(["\\] | 0..0x1f) | '\\'["\\/bfnrt] | '\\u'[0-9a-fA-F]{4} | '\\'^(["\\/bfnrtu]|0..0x1f))* %parse_string) '"' @exit;
 }%%
 
+static int
+match_i(VALUE regexp, VALUE klass, VALUE memo)
+{
+    if (regexp == Qundef) return ST_STOP;
+    if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
+      RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
+        rb_ary_push(memo, klass);
+        return ST_STOP;
+    }
+    return ST_CONTINUE;
+}
+
 static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
 {
     int cs = EVIL;
+    VALUE match_string;
 
     *result = rb_str_buf_new(0);
     %% write init;
     json->memo = p;
     %% write exec;
 
+    if (json->create_additions && RTEST(match_string = json->match_string)) {
+          VALUE klass;
+          VALUE memo = rb_ary_new2(2);
+          rb_ary_push(memo, *result);
+          rb_hash_foreach(match_string, match_i, memo);
+          klass = rb_ary_entry(memo, 1);
+          if (RTEST(klass)) {
+              *result = rb_funcall(klass, i_json_create, 1, *result);
+          }
+    }
+
     if (json->symbolize_names && json->parsing_name) {
       *result = rb_str_intern(*result);
     }
@@ -632,26 +656,25 @@ static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
             }
             tmp = ID2SYM(i_allow_nan);
             if (option_given_p(opts, tmp)) {
-                VALUE allow_nan = rb_hash_aref(opts, tmp);
-                json->allow_nan = RTEST(allow_nan) ? 1 : 0;
+                json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
             } else {
                 json->allow_nan = 0;
             }
             tmp = ID2SYM(i_symbolize_names);
             if (option_given_p(opts, tmp)) {
-                VALUE symbolize_names = rb_hash_aref(opts, tmp);
-                json->symbolize_names = RTEST(symbolize_names) ? 1 : 0;
+                json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
             } else {
                 json->symbolize_names = 0;
             }
             tmp = ID2SYM(i_create_additions);
             if (option_given_p(opts, tmp)) {
-                VALUE create_additions = rb_hash_aref(opts, tmp);
-                if (RTEST(create_additions)) {
-                    json->create_id = rb_funcall(mJSON, i_create_id, 0);
-                } else {
-                    json->create_id = Qnil;
-                }
+                json->create_additions = RTEST(rb_hash_aref(opts, tmp));
+            } else {
+                json->create_additions = 1;
+            }
+            tmp = ID2SYM(i_create_id);
+            if (option_given_p(opts, tmp)) {
+                json->create_id = rb_hash_aref(opts, tmp);
             } else {
                 json->create_id = rb_funcall(mJSON, i_create_id, 0);
             }
@@ -667,10 +690,18 @@ static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
             } else {
                 json->array_class = Qnil;
             }
+            tmp = ID2SYM(i_match_string);
+            if (option_given_p(opts, tmp)) {
+                VALUE match_string = rb_hash_aref(opts, tmp);
+                json->match_string = RTEST(match_string) ? match_string : Qnil;
+            } else {
+                json->match_string = Qnil;
+            }
         }
     } else {
         json->max_nesting = 19;
         json->allow_nan = 0;
+        json->create_additions = 1;
         json->create_id = rb_funcall(mJSON, i_create_id, 0);
         json->object_class = Qnil;
         json->array_class = Qnil;
@@ -721,6 +752,7 @@ static void JSON_mark(JSON_Parser *json)
     rb_gc_mark_maybe(json->create_id);
     rb_gc_mark_maybe(json->object_class);
     rb_gc_mark_maybe(json->array_class);
+    rb_gc_mark_maybe(json->match_string);
 }
 
 static void JSON_free(JSON_Parser *json)
@@ -773,6 +805,8 @@ void Init_parser()
     i_symbolize_names = rb_intern("symbolize_names");
     i_object_class = rb_intern("object_class");
     i_array_class = rb_intern("array_class");
+    i_match = rb_intern("match");
+    i_match_string = rb_intern("match_string");
     i_key_p = rb_intern("key?");
     i_deep_const_get = rb_intern("deep_const_get");
 #ifdef HAVE_RUBY_ENCODING_H

data/java/src/json/ext/ByteListTranscoder.java

@@ -0,0 +1,167 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby and GPLv2 licenses; see COPYING and GPL files
+ * for details.
+ */
+package json.ext;
+
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.util.ByteList;
+
+/**
+ * A class specialized in transcoding a certain String format into another,
+ * using UTF-8 ByteLists as both input and output.
+ */
+abstract class ByteListTranscoder {
+    protected final ThreadContext context;
+
+    protected ByteList src;
+    protected int srcEnd;
+    /** Position where the last read character started */
+    protected int charStart;
+    /** Position of the next character to read */
+    protected int pos;
+
+    private ByteList out;
+    /**
+     * When a character that can be copied straight into the output is found,
+     * its index is stored on this variable, and copying is delayed until
+     * the sequence of characters that can be copied ends.
+     *
+     * <p>The variable stores -1 when not in a plain sequence.
+     */
+    private int quoteStart = -1;
+
+    protected ByteListTranscoder(ThreadContext context) {
+        this.context = context;
+    }
+
+    protected void init(ByteList src, ByteList out) {
+        this.init(src, 0, src.length(), out);
+    }
+
+    protected void init(ByteList src, int start, int end, ByteList out) {
+        this.src = src;
+        this.pos = start;
+        this.charStart = start;
+        this.srcEnd = end;
+        this.out = out;
+    }
+
+    /**
+     * Returns whether there are any characters left to be read.
+     */
+    protected boolean hasNext() {
+        return pos < srcEnd;
+    }
+
+    /**
+     * Returns the next character in the buffer.
+     */
+    private char next() {
+        return src.charAt(pos++);
+    }
+
+    /**
+     * Reads an UTF-8 character from the input and returns its code point,
+     * while advancing the input position.
+     *
+     * <p>Raises an {@link #invalidUtf8()} exception if an invalid byte
+     * is found.
+     */
+    protected int readUtf8Char() {
+        charStart = pos;
+        char head = next();
+        if (head <= 0x7f) { // 0b0xxxxxxx (ASCII)
+            return head;
+        }
+        if (head <= 0xbf) { // 0b10xxxxxx
+            throw invalidUtf8(); // tail byte with no head
+        }
+        if (head <= 0xdf) { // 0b110xxxxx
+            ensureMin(1);
+            int cp = ((head  & 0x1f) << 6)
+                     | nextPart();
+            if (cp < 0x0080) throw invalidUtf8();
+            return cp;
+        }
+        if (head <= 0xef) { // 0b1110xxxx
+            ensureMin(2);
+            int cp = ((head & 0x0f) << 12)
+                     | (nextPart()  << 6)
+                     | nextPart();
+            if (cp < 0x0800) throw invalidUtf8();
+            return cp;
+        }
+        if (head <= 0xf7) { // 0b11110xxx
+            ensureMin(3);
+            int cp = ((head & 0x07) << 18)
+                     | (nextPart()  << 12)
+                     | (nextPart()  << 6)
+                     | nextPart();
+            if (!Character.isValidCodePoint(cp)) throw invalidUtf8();
+            return cp;
+        }
+        // 0b11111xxx?
+        throw invalidUtf8();
+    }
+
+    /**
+     * Throws a GeneratorError if the input list doesn't have at least this
+     * many bytes left.
+     */
+    protected void ensureMin(int n) {
+        if (pos + n > srcEnd) throw incompleteUtf8();
+    }
+
+    /**
+     * Reads the next byte of a multi-byte UTF-8 character and returns its
+     * contents (lower 6 bits).
+     *
+     * <p>Throws a GeneratorError if the byte is not a valid tail.
+     */
+    private int nextPart() {
+        char c = next();
+        // tail bytes must be 0b10xxxxxx
+        if ((c & 0xc0) != 0x80) throw invalidUtf8();
+        return c & 0x3f;
+    }
+
+
+    protected void quoteStart() {
+        if (quoteStart == -1) quoteStart = charStart;
+    }
+
+    /**
+     * When in a sequence of characters that can be copied directly,
+     * interrupts the sequence and copies it to the output buffer.
+     *
+     * @param endPos The offset until which the direct character quoting should
+     *               occur. You may pass {@link #pos} to quote until the most
+     *               recently read character, or {@link #charStart} to quote
+     *               until the character before it.
+     */
+    protected void quoteStop(int endPos) {
+        if (quoteStart != -1) {
+            out.append(src, quoteStart, endPos - quoteStart);
+            quoteStart = -1;
+        }
+    }
+
+    protected void append(int b) {
+        out.append(b);
+    }
+
+    protected void append(byte[] origin, int start, int length) {
+        out.append(origin, start, length);
+    }
+
+
+    protected abstract RaiseException invalidUtf8();
+
+    protected RaiseException incompleteUtf8() {
+        return invalidUtf8();
+    }
+}

data/java/src/json/ext/Generator.java

@@ -0,0 +1,441 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ * 
+ * Distributed under the Ruby and GPLv2 licenses; see COPYING and GPL files
+ * for details.
+ */
+package json.ext;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyHash;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+public final class Generator {
+    private Generator() {
+        throw new RuntimeException();
+    }
+
+    /**
+     * Encodes the given object as a JSON string, using the given handler.
+     */
+    static <T extends IRubyObject> RubyString
+            generateJson(ThreadContext context, T object,
+                         Handler<? super T> handler, IRubyObject[] args) {
+        Session session = new Session(context, args.length > 0 ? args[0]
+                                                               : null);
+        return session.infect(handler.generateNew(session, object));
+    }
+
+    /**
+     * Encodes the given object as a JSON string, detecting the appropriate handler
+     * for the given object.
+     */
+    static <T extends IRubyObject> RubyString
+            generateJson(ThreadContext context, T object, IRubyObject[] args) {
+        Handler<? super T> handler = getHandlerFor(context.getRuntime(), object);
+        return generateJson(context, object, handler, args);
+    }
+
+    /**
+     * Encodes the given object as a JSON string, using the appropriate
+     * handler if one is found or calling #to_json if not.
+     */
+    public static <T extends IRubyObject> RubyString
+            generateJson(ThreadContext context, T object,
+                         GeneratorState config) {
+        Session session = new Session(context, config);
+        Handler<? super T> handler = getHandlerFor(context.getRuntime(), object);
+        return handler.generateNew(session, object);
+    }
+
+    /**
+     * Returns the best serialization handler for the given object.
+     */
+    // Java's generics can't handle this satisfactorily, so I'll just leave
+    // the best I could get and ignore the warnings
+    @SuppressWarnings("unchecked")
+    private static <T extends IRubyObject>
+            Handler<? super T> getHandlerFor(Ruby runtime, T object) {
+        RubyClass metaClass = object.getMetaClass();
+        if (metaClass == runtime.getString()) return (Handler)STRING_HANDLER;
+        if (metaClass == runtime.getFixnum()) return (Handler)FIXNUM_HANDLER;
+        if (metaClass == runtime.getHash())   return (Handler)HASH_HANDLER;
+        if (metaClass == runtime.getArray())  return (Handler)ARRAY_HANDLER;
+        if (object.isNil())                   return (Handler)NIL_HANDLER;
+        if (object == runtime.getTrue())      return (Handler)TRUE_HANDLER;
+        if (object == runtime.getFalse())     return (Handler)FALSE_HANDLER;
+        if (metaClass == runtime.getFloat())  return (Handler)FLOAT_HANDLER;
+        if (metaClass == runtime.getBignum()) return (Handler)BIGNUM_HANDLER;
+        return GENERIC_HANDLER;
+    }
+
+
+    /* Generator context */
+
+    /**
+     * A class that concentrates all the information that is shared by
+     * generators working on a single session.
+     * 
+     * <p>A session is defined as the process of serializing a single root
+     * object; any handler directly called by container handlers (arrays and
+     * hashes/objects) shares this object with its caller.
+     * 
+     * <p>Note that anything called indirectly (via {@link GENERIC_HANDLER})
+     * won't be part of the session.
+     */
+    static class Session {
+        private final ThreadContext context;
+        private GeneratorState state;
+        private IRubyObject possibleState;
+        private RuntimeInfo info;
+        private StringEncoder stringEncoder;
+
+        private boolean tainted = false;
+        private boolean untrusted = false;
+
+        Session(ThreadContext context, GeneratorState state) {
+            this.context = context;
+            this.state = state;
+        }
+
+        Session(ThreadContext context, IRubyObject possibleState) {
+            this.context = context;
+            this.possibleState = possibleState == null || possibleState.isNil()
+                    ? null : possibleState;
+        }
+
+        public ThreadContext getContext() {
+            return context;
+        }
+
+        public Ruby getRuntime() {
+            return context.getRuntime();
+        }
+
+        public GeneratorState getState() {
+            if (state == null) {
+                state = GeneratorState.fromState(context, getInfo(), possibleState);
+            }
+            return state;
+        }
+
+        public RuntimeInfo getInfo() {
+            if (info == null) info = RuntimeInfo.forRuntime(getRuntime());
+            return info;
+        }
+
+        public StringEncoder getStringEncoder() {
+            if (stringEncoder == null) {
+                stringEncoder = new StringEncoder(context, getState().asciiOnly());
+            }
+            return stringEncoder;
+        }
+
+        public void infectBy(IRubyObject object) {
+            if (object.isTaint()) tainted = true;
+            if (object.isUntrusted()) untrusted = true;
+        }
+
+        public <T extends IRubyObject> T infect(T object) {
+            if (tainted) object.setTaint(true);
+            if (untrusted) object.setUntrusted(true);
+            return object;
+        }
+    }
+
+
+    /* Handler base classes */
+
+    private static abstract class Handler<T extends IRubyObject> {
+        /**
+         * Returns an estimative of how much space the serialization of the
+         * given object will take. Used for allocating enough buffer space
+         * before invoking other methods.
+         */
+        int guessSize(Session session, T object) {
+            return 4;
+        }
+
+        RubyString generateNew(Session session, T object) {
+            ByteList buffer = new ByteList(guessSize(session, object));
+            generate(session, object, buffer);
+            return RubyString.newString(session.getRuntime(), buffer);
+        }
+
+        abstract void generate(Session session, T object, ByteList buffer);
+    }
+
+    /**
+     * A handler that returns a fixed keyword regardless of the passed object.
+     */
+    private static class KeywordHandler<T extends IRubyObject>
+            extends Handler<T> {
+        private final ByteList keyword;
+
+        private KeywordHandler(String keyword) {
+            this.keyword = new ByteList(ByteList.plain(keyword), false);
+        }
+
+        @Override
+        int guessSize(Session session, T object) {
+            return keyword.length();
+        }
+
+        @Override
+        RubyString generateNew(Session session, T object) {
+            return RubyString.newStringShared(session.getRuntime(), keyword);
+        }
+
+        @Override
+        void generate(Session session, T object, ByteList buffer) {
+            buffer.append(keyword);
+        }
+    }
+
+
+    /* Handlers */
+
+    static final Handler<RubyBignum> BIGNUM_HANDLER =
+        new Handler<RubyBignum>() {
+            @Override
+            void generate(Session session, RubyBignum object, ByteList buffer) {
+                // JRUBY-4751: RubyBignum.to_s() returns generic object
+                // representation (fixed in 1.5, but we maintain backwards
+                // compatibility; call to_s(IRubyObject[]) then
+                buffer.append(((RubyString)object.to_s(IRubyObject.NULL_ARRAY)).getByteList());
+            }
+        };
+
+    static final Handler<RubyFixnum> FIXNUM_HANDLER =
+        new Handler<RubyFixnum>() {
+            @Override
+            void generate(Session session, RubyFixnum object, ByteList buffer) {
+                buffer.append(object.to_s().getByteList());
+            }
+        };
+
+    static final Handler<RubyFloat> FLOAT_HANDLER =
+        new Handler<RubyFloat>() {
+            @Override
+            void generate(Session session, RubyFloat object, ByteList buffer) {
+                double value = RubyFloat.num2dbl(object);
+
+                if (Double.isInfinite(value) || Double.isNaN(value)) {
+                    if (!session.getState().allowNaN()) {
+                        throw Utils.newException(session.getContext(),
+                                Utils.M_GENERATOR_ERROR,
+                                object + " not allowed in JSON");
+                    }
+                }
+                buffer.append(((RubyString)object.to_s()).getByteList());
+            }
+        };
+
+    static final Handler<RubyArray> ARRAY_HANDLER =
+        new Handler<RubyArray>() {
+            @Override
+            int guessSize(Session session, RubyArray object) {
+                GeneratorState state = session.getState();
+                int depth = state.getDepth();
+                int perItem =
+                    4                                           // prealloc
+                    + (depth + 1) * state.getIndent().length()  // indent
+                    + 1 + state.getArrayNl().length();          // ',' arrayNl
+                return 2 + object.size() * perItem;
+            }
+
+            @Override
+            void generate(Session session, RubyArray object, ByteList buffer) {
+                ThreadContext context = session.getContext();
+                Ruby runtime = context.getRuntime();
+                GeneratorState state = session.getState();
+                int depth = state.increaseDepth();
+
+                ByteList indentUnit = state.getIndent();
+                byte[] shift = Utils.repeat(indentUnit, depth);
+
+                ByteList arrayNl = state.getArrayNl();
+                byte[] delim = new byte[1 + arrayNl.length()];
+                delim[0] = ',';
+                System.arraycopy(arrayNl.unsafeBytes(), arrayNl.begin(), delim, 1,
+                        arrayNl.length());
+
+                session.infectBy(object);
+
+                buffer.append((byte)'[');
+                buffer.append(arrayNl);
+                boolean firstItem = true;
+                for (int i = 0, t = object.getLength(); i < t; i++) {
+                    IRubyObject element = object.eltInternal(i);
+                    session.infectBy(element);
+                    if (firstItem) {
+                        firstItem = false;
+                    } else {
+                        buffer.append(delim);
+                    }
+                    buffer.append(shift);
+                    Handler<IRubyObject> handler = getHandlerFor(runtime, element);
+                    handler.generate(session, element, buffer);
+                }
+
+                state.decreaseDepth();
+                if (arrayNl.length() != 0) {
+                    buffer.append(arrayNl);
+                    buffer.append(shift, 0, state.getDepth() * indentUnit.length());
+                }
+
+                buffer.append((byte)']');
+            }
+        };
+
+    static final Handler<RubyHash> HASH_HANDLER =
+        new Handler<RubyHash>() {
+            @Override
+            int guessSize(Session session, RubyHash object) {
+                GeneratorState state = session.getState();
+                int perItem =
+                    12    // key, colon, comma
+                    + (state.getDepth() + 1) * state.getIndent().length()
+                    + state.getSpaceBefore().length()
+                    + state.getSpace().length();
+                return 2 + object.size() * perItem;
+            }
+
+            @Override
+            void generate(final Session session, RubyHash object,
+                          final ByteList buffer) {
+                ThreadContext context = session.getContext();
+                final Ruby runtime = context.getRuntime();
+                final GeneratorState state = session.getState();
+                final int depth = state.increaseDepth();
+
+                final ByteList objectNl = state.getObjectNl();
+                final byte[] indent = Utils.repeat(state.getIndent(), depth);
+                final ByteList spaceBefore = state.getSpaceBefore();
+                final ByteList space = state.getSpace();
+
+                buffer.append((byte)'{');
+                buffer.append(objectNl);
+                object.visitAll(new RubyHash.Visitor() {
+                    private boolean firstPair = true;
+
+                    @Override
+                    public void visit(IRubyObject key, IRubyObject value) {
+                        if (firstPair) {
+                            firstPair = false;
+                        } else {
+                            buffer.append((byte)',');
+                            buffer.append(objectNl);
+                        }
+                        if (objectNl.length() != 0) buffer.append(indent);
+
+                        STRING_HANDLER.generate(session, key.asString(), buffer);
+                        session.infectBy(key);
+
+                        buffer.append(spaceBefore);
+                        buffer.append((byte)':');
+                        buffer.append(space);
+
+                        Handler<IRubyObject> valueHandler = getHandlerFor(runtime, value);
+                        valueHandler.generate(session, value, buffer);
+                        session.infectBy(value);
+                    }
+                });
+                state.decreaseDepth();
+                if (objectNl.length() != 0) {
+                    buffer.append(objectNl);
+                    if (indent.length != 0) {
+                        for (int i = 0; i < state.getDepth(); i++) {
+                            buffer.append(indent);
+                        }
+                    }
+                }
+                buffer.append((byte)'}');
+            }
+        };
+
+    static final Handler<RubyString> STRING_HANDLER =
+        new Handler<RubyString>() {
+            @Override
+            int guessSize(Session session, RubyString object) {
+                // for most applications, most strings will be just a set of
+                // printable ASCII characters without any escaping, so let's
+                // just allocate enough space for that + the quotes
+                return 2 + object.getByteList().length();
+            }
+
+            @Override
+            void generate(Session session, RubyString object, ByteList buffer) {
+                RuntimeInfo info = session.getInfo();
+                RubyString src;
+
+                if (info.encodingsSupported() &&
+                        object.encoding(session.getContext()) != info.utf8) {
+                    src = (RubyString)object.encode(session.getContext(),
+                                                    info.utf8);
+                } else {
+                    src = object;
+                }
+
+                session.getStringEncoder().encode(src.getByteList(), buffer);
+            }
+        };
+
+    static final Handler<RubyBoolean> TRUE_HANDLER =
+        new KeywordHandler<RubyBoolean>("true");
+    static final Handler<RubyBoolean> FALSE_HANDLER =
+        new KeywordHandler<RubyBoolean>("false");
+    static final Handler<IRubyObject> NIL_HANDLER =
+        new KeywordHandler<IRubyObject>("null");
+
+    /**
+     * The default handler (<code>Object#to_json</code>): coerces the object
+     * to string using <code>#to_s</code>, and serializes that string.
+     */
+    static final Handler<IRubyObject> OBJECT_HANDLER =
+        new Handler<IRubyObject>() {
+            @Override
+            RubyString generateNew(Session session, IRubyObject object) {
+                RubyString str = object.asString();
+                return STRING_HANDLER.generateNew(session, str);
+            }
+
+            @Override
+            void generate(Session session, IRubyObject object, ByteList buffer) {
+                RubyString str = object.asString();
+                STRING_HANDLER.generate(session, str, buffer);
+            }
+        };
+
+    /**
+     * A handler that simply calls <code>#to_json(state)</code> on the
+     * given object.
+     */
+    static final Handler<IRubyObject> GENERIC_HANDLER =
+        new Handler<IRubyObject>() {
+            @Override
+            RubyString generateNew(Session session, IRubyObject object) {
+                IRubyObject result =
+                    object.callMethod(session.getContext(), "to_json",
+                          new IRubyObject[] {session.getState()});
+                if (result instanceof RubyString) return (RubyString)result;
+                throw session.getRuntime().newTypeError("to_json must return a String");
+            }
+
+            @Override
+            void generate(Session session, IRubyObject object, ByteList buffer) {
+                RubyString result = generateNew(session, object);
+                buffer.append(result.getByteList());
+            }
+        };
+}