jubilee 1.0.2 → 1.1.0.rc1

data/java/src/org/jruby/jubilee/RackResponse.java

@@ -1,7 +1,5 @@
 package org.jruby.jubilee;
 
-import org.vertx.java.core.http.HttpServerResponse;
-
 /**
  * Created with IntelliJ IDEA.
  * User: isaiah
@@ -9,5 +7,5 @@ import org.vertx.java.core.http.HttpServerResponse;
  * Time: 5:39 PM
  */
 public interface RackResponse {
-    public void respond(HttpServerResponse response);
+    public void respond(RubyHttpServerResponse response);
 }

data/java/src/org/jruby/jubilee/RubyHttpServerResponse.java

@@ -0,0 +1,88 @@
+package org.jruby.jubilee;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.http.HttpServerResponse;
+
+import java.util.Arrays;
+
+/**
+ * Created by isaiah on 21/12/2013.
+ */
+@JRubyClass(name = "HttpServerResponse")
+public class RubyHttpServerResponse extends RubyObject {
+  private HttpServerResponse resp;
+  private String lineSeparator;
+
+  public static RubyClass createHttpServerResponseClass(final Ruby runtime) {
+    RubyModule mJubilee = runtime.getOrCreateModule("Jubilee");
+    RubyClass klazz = mJubilee.defineClassUnder("HttpServerResponse", runtime.getObject(), new ObjectAllocator() {
+      @Override
+      public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+        return new RubyHttpServerResponse(ruby, rubyClass);
+      }
+    });
+    klazz.defineAnnotatedMethods(RubyHttpServerResponse.class);
+    return klazz;
+  }
+
+  public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass) {
+    super(ruby, rubyClass);
+  }
+
+  public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass, HttpServerResponse resp) {
+    super(ruby, rubyClass);
+    this.resp = resp;
+    this.lineSeparator = System.getProperty("line.separator");
+  }
+
+  @JRubyMethod
+  public IRubyObject write(ThreadContext context, IRubyObject string) {
+    this.resp.write(string.asJavaString());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "status_code=")
+  public IRubyObject setStatusCode(ThreadContext context, IRubyObject statusCode) {
+    this.resp.setStatusCode(RubyNumeric.num2int(statusCode));
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "chunked=")
+  public IRubyObject setChunked(ThreadContext context, IRubyObject chunked) {
+    this.resp.setChunked(chunked.isTrue());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "put_header")
+  public IRubyObject putHeader(ThreadContext context, IRubyObject key, IRubyObject val) {
+    String cookie = val.asJavaString();
+    if (cookie.indexOf(this.lineSeparator) != -1)
+      this.resp.putHeader(key.asJavaString(),
+              Arrays.asList(val.asJavaString().split(this.lineSeparator)));
+    else this.resp.putHeader(key.asJavaString(), val.asJavaString());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "send_file")
+  public IRubyObject sendFile(ThreadContext context, IRubyObject filePath) {
+    this.resp.sendFile(filePath.asJavaString());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod
+  public IRubyObject end(ThreadContext context) {
+    this.resp.end();
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "put_default_headers")
+  public IRubyObject putDefaultHeaders(ThreadContext context) {
+    this.resp.putHeader("Server", Const.JUBILEE_VERSION);
+    return context.runtime.getNil();
+  }
+}

data/java/src/org/jruby/jubilee/{Server.java → RubyServer.java}

@@ -14,7 +14,9 @@ import org.vertx.java.core.http.HttpServerRequest;
 import org.vertx.java.core.json.JsonArray;
 import org.vertx.java.core.json.JsonObject;
 
-public class Server extends RubyObject {
+import java.io.IOException;
+
+public class RubyServer extends RubyObject {
     private Vertx vertx;
     private HttpServer httpServer;
     private RackApplication app;
@@ -23,7 +25,6 @@ public class Server extends RubyObject {
     private String keyStorePath;
     private String keyStorePassword;
     private String eventBusPrefix;
-    private int numberOfWorkers;
     private int port;
     private String host;
     private int clusterPort;
@@ -32,16 +33,16 @@ public class Server extends RubyObject {
     public static void createServerClass(Ruby runtime) {
         RubyModule mJubilee = runtime.defineModule("Jubilee");
         RubyClass serverClass = mJubilee.defineClassUnder("VertxServer", runtime.getObject(), ALLOCATOR);
-        serverClass.defineAnnotatedMethods(Server.class);
+        serverClass.defineAnnotatedMethods(RubyServer.class);
     }
 
     private static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
-            return new Server(ruby, rubyClass);
+            return new RubyServer(ruby, rubyClass);
         }
     };
 
-    public Server(Ruby ruby, RubyClass rubyClass) {
+    public RubyServer(Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
     }
 
@@ -49,7 +50,8 @@ public class Server extends RubyObject {
      * Initialize jubilee server, take a rack application and a configuration hash as parameter
      *
      * @param context
-     * @param args
+     * @param app
+     * @param config
      * @param block
      * @return
      */
@@ -66,19 +68,16 @@ public class Server extends RubyObject {
         RubySymbol keystore_path_k = runtime.newSymbol("keystore_path");
         RubySymbol keystore_password_k = runtime.newSymbol("keystore_password");
         RubySymbol eventbus_prefix_k = runtime.newSymbol("eventbus_prefix");
-        RubySymbol number_of_workers_k = runtime.newSymbol("number_of_workers");
 
         /* retrieve from passed in options */
         this.port = Integer.parseInt(options.op_aref(context, port_k).toString());
         this.host = options.op_aref(context, host_k).toString();
 
         this.ssl = options.op_aref(context, ssl_k).isTrue();
-        this.numberOfWorkers = Integer.parseInt(options.op_aref(context, number_of_workers_k).toString());
         if (options.has_key_p(keystore_path_k).isTrue()) {
             this.keyStorePath = options.op_aref(context, keystore_path_k).toString();
             this.keyStorePassword = options.op_aref(context, keystore_password_k).toString();
         }
-        this.app = new RackApplication(app, this.ssl, this.numberOfWorkers);
         if (options.has_key_p(eventbus_prefix_k).isTrue())
             this.eventBusPrefix = options.op_aref(context, eventbus_prefix_k).toString();
 
@@ -95,6 +94,12 @@ public class Server extends RubyObject {
         }
 
         httpServer = vertx.createHttpServer();
+        try {
+            this.app = new RackApplication(vertx, context, app, this.ssl);
+            if (block.isGiven()) block.yieldSpecific(context, this);
+        } catch (IOException e) {
+            // noop
+        }
         return this;
     }
 
@@ -124,6 +129,7 @@ public class Server extends RubyObject {
                 .setKeyStorePassword(this.keyStorePassword);
         httpServer.listen(this.port, this.host);
         this.running = true;
+        if (block.isGiven()) block.yieldSpecific(context, this);
         return this;
     }
 
@@ -152,13 +158,10 @@ public class Server extends RubyObject {
     @JRubyMethod(name = {"stop", "close"}, optional = 1)
     public IRubyObject close(ThreadContext context, IRubyObject[] args, Block block) {
         if (running) {
-            if (args.length == 1)
-                app.shutdown(args[0].isTrue());
-            else
-                app.shutdown(false);
-
             this.running = false;
             httpServer.close();
+            // DO I need to stop?
+            //vertx.stop();
             if (block.isGiven()) block.yieldSpecific(context);
         } else {
             getRuntime().getOutputStream().println("jubilee server not running?");

data/java/src/org/jruby/jubilee/impl/RackEnvironment.java

@@ -0,0 +1,157 @@
+package org.jruby.jubilee.impl;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyString;
+
+import org.jruby.jubilee.Const;
+import org.jruby.jubilee.RackInput;
+import org.jruby.jubilee.utils.RubyHelper;
+import org.vertx.java.core.MultiMap;
+import org.vertx.java.core.http.HttpServerRequest;
+import org.vertx.java.core.http.HttpVersion;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RackEnvironment {
+
+    // When adding a key to the enum be sure to add its RubyString equivalent
+    // to populateRackKeyMap below
+    static enum RACK_KEY {
+        RACK_INPUT, RACK_ERRORS, REQUEST_METHOD, SCRIPT_NAME,
+        PATH_INFO, QUERY_STRING, SERVER_NAME, SERVER_PORT,
+        CONTENT_TYPE, REQUEST_URI, REMOTE_ADDR, URL_SCHEME,
+        VERSION, MULTITHREAD, MULTIPROCESS, RUN_ONCE, CONTENT_LENGTH,
+        HTTPS, HTTP_VERSION
+    }
+    static final int NUM_RACK_KEYS = RACK_KEY.values().length;
+
+    public RackEnvironment(final Ruby runtime) throws IOException {
+        this.runtime = runtime;
+        rackVersion = RubyArray.newArray(runtime, RubyFixnum.one(runtime), RubyFixnum.four(runtime));
+        errors = new RubyIO(runtime, runtime.getErr());
+        errors.setAutoclose(false);
+
+        populateRackKeyMap();
+    }
+
+    private void populateRackKeyMap() {
+        putRack("rack.input", RACK_KEY.RACK_INPUT);
+        putRack("rack.errors", RACK_KEY.RACK_ERRORS);
+        putRack("REQUEST_METHOD", RACK_KEY.REQUEST_METHOD);
+        putRack("SCRIPT_NAME", RACK_KEY.SCRIPT_NAME);
+        putRack("PATH_INFO", RACK_KEY.PATH_INFO);
+        putRack("QUERY_STRING", RACK_KEY.QUERY_STRING);
+        putRack("SERVER_NAME", RACK_KEY.SERVER_NAME);
+        putRack("SERVER_PORT", RACK_KEY.SERVER_PORT);
+        putRack("HTTP_VERSION", RACK_KEY.HTTP_VERSION);
+        putRack("CONTENT_TYPE", RACK_KEY.CONTENT_TYPE);
+        putRack("REQUEST_URI", RACK_KEY.REQUEST_URI);
+        putRack("REMOTE_ADDR", RACK_KEY.REMOTE_ADDR);
+        putRack("rack.url_scheme", RACK_KEY.URL_SCHEME);
+        putRack("rack.version", RACK_KEY.VERSION);
+        putRack("rack.multithread", RACK_KEY.MULTITHREAD);
+        putRack("rack.multiprocess", RACK_KEY.MULTIPROCESS);
+        putRack("rack.run_once", RACK_KEY.RUN_ONCE);
+        putRack("CONTENT_LENGTH", RACK_KEY.CONTENT_LENGTH);
+        putRack("HTTPS", RACK_KEY.HTTPS);
+    }
+
+    private void putRack(String key, RACK_KEY value) {
+        rackKeyMap.put(RubyHelper.toUsAsciiRubyString(runtime, key), value);
+    }
+
+    public RubyHash getEnv(final HttpServerRequest request,
+                           final RackInput input,
+                           final boolean isSSL) throws IOException {
+        // XXX
+        String contextPath = "/";
+        MultiMap headers = request.headers();
+        // TODO: Should we only use this faster RackEnvironmentHash if we detect
+        // specific JRuby versions that we know are compatible?
+        final RackEnvironmentHash env = new RackEnvironmentHash(runtime, headers, rackKeyMap);
+        env.lazyPut(RACK_KEY.RACK_INPUT, input, false);
+        env.lazyPut(RACK_KEY.RACK_ERRORS, errors, false);
+
+        // Don't use request.getPathInfo because that gets decoded by the container
+        String pathInfo = request.path();
+
+        // strip contextPath and servletPath from pathInfo
+        if (pathInfo.startsWith(contextPath) && !contextPath.equals("/")) {
+            pathInfo = pathInfo.substring(contextPath.length());
+        }
+
+        String scriptName = contextPath;
+        // SCRIPT_NAME should be an empty string for the root
+        if (scriptName.equals("/")) {
+            scriptName = "";
+        }
+
+        env.lazyPut(RACK_KEY.REQUEST_METHOD, request.method(), true);
+        env.lazyPut(RACK_KEY.SCRIPT_NAME, scriptName, false);
+        env.lazyPut(RACK_KEY.PATH_INFO, pathInfo, false);
+        env.lazyPut(RACK_KEY.QUERY_STRING, orEmpty(request.query()), false);
+        env.lazyPut(RACK_KEY.SERVER_NAME, Const.LOCALHOST, false);
+        env.lazyPut(RACK_KEY.SERVER_PORT, Const.PORT_80, true);
+        env.lazyPut(RACK_KEY.HTTP_VERSION,
+                request.version() == HttpVersion.HTTP_1_1 ? Const.HTTP_11 : Const.HTTP_10, true);
+        env.lazyPut(RACK_KEY.CONTENT_TYPE, headers.get(HttpHeaders.Names.CONTENT_TYPE), true);
+        env.lazyPut(RACK_KEY.REQUEST_URI, scriptName + pathInfo, false);
+        env.lazyPut(RACK_KEY.REMOTE_ADDR, getRemoteAddr(request), true);
+        env.lazyPut(RACK_KEY.URL_SCHEME, isSSL? Const.HTTPS : Const.HTTP, true);
+        env.lazyPut(RACK_KEY.VERSION, rackVersion, false);
+        env.lazyPut(RACK_KEY.MULTITHREAD, runtime.getTrue(), false);
+        env.lazyPut(RACK_KEY.MULTIPROCESS, runtime.getFalse(), false);
+        env.lazyPut(RACK_KEY.RUN_ONCE, runtime.getFalse(), false);
+
+
+        final int contentLength = getContentLength(headers);
+        if (contentLength >= 0) {
+            env.lazyPut(RACK_KEY.CONTENT_LENGTH, contentLength + "", true);
+        }
+
+        if (isSSL) {
+            env.lazyPut(RACK_KEY.HTTPS, "on", true);
+        }
+
+        return env;
+    }
+
+    private static String getRemoteAddr(final HttpServerRequest request) {
+        InetSocketAddress sourceAddress = request.remoteAddress();
+        if(sourceAddress == null) {
+            return "";
+        }
+        InetAddress address = sourceAddress.getAddress();
+        if(address == null) {
+            return "";
+        }
+        return address.getHostAddress();
+    }
+
+    private static int getContentLength(final MultiMap headers) {
+        final String contentLengthStr = headers.get(HttpHeaders.Names.CONTENT_LENGTH);
+        if (contentLengthStr == null || contentLengthStr.isEmpty()) {
+            return -1;
+        }
+        return Integer.parseInt(contentLengthStr);
+    }
+
+    private String orEmpty(String val) {
+        return val == null ? "" : val;
+    }
+
+    private final Ruby runtime;
+    private final RubyArray rackVersion;
+    private final RubyIO errors;
+    private final Map<RubyString, RACK_KEY> rackKeyMap = new HashMap<>();
+}

data/java/src/org/jruby/jubilee/impl/RackEnvironmentHash.java

@@ -0,0 +1,449 @@
+package org.jruby.jubilee.impl;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.jubilee.utils.RubyHelper;
+import org.vertx.java.core.MultiMap;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RackEnvironmentHash extends RubyHash {
+
+    public RackEnvironmentHash(final Ruby runtime, final MultiMap headers,
+                               final Map<RubyString, RackEnvironment.RACK_KEY> rackKeyMap) {
+        super(runtime);
+        this.headers = headers;
+        this.rackKeyMap = rackKeyMap;
+        this.headerKeyMap = new HashMap<>();
+    }
+
+    public void lazyPut(RackEnvironment.RACK_KEY rackKey, final Object value, boolean usAscii) {
+        rackValues[rackKey.ordinal()] = value;
+        usAsciiValues[rackKey.ordinal()] = usAscii;
+    }
+
+    // synchronized probably isn't needed here since we create a new RackEnvironment
+    // per request, but we can't guarantee users aren't spawning a new thread and
+    // passing the env to that new thread
+    private synchronized void fillKey(final IRubyObject rubyKey) {
+        if (!filledEntireHash) {
+            if (rubyKey instanceof RubyString && !containsKey(rubyKey)) {
+                if (! filledHeaderKeyMap) populateHeaderKeyMap();
+                byte[] keyBytes = ((RubyString) rubyKey).getBytes();
+                if (keyBytes.length > 5 && keyBytes[0] == 'H'
+                        && keyBytes[1] == 'T' && keyBytes[2] == 'T'
+                        && keyBytes[3] == 'P' && keyBytes[4] == '_') {
+
+                    fillHeaderKey((RubyString) rubyKey);
+                } else {
+                    fillRackKey((RubyString) rubyKey);
+                }
+            }
+        }
+    }
+    private synchronized void fillEntireHash() {
+        if (!filledEntireHash) {
+            for (RubyString key : rackKeyMap.keySet()) {
+                fillRackKey(key);
+            }
+
+            for (String headerKey : headers.names()) {
+                RubyString rubyKey = RubyHelper.toUsAsciiRubyString(getRuntime(), rackHeaderNameToBytes(headerKey));
+                putHeaderKey(rubyKey, headerKey);
+                fillHeaderKey(rubyKey, headerKey);
+            }
+            filledEntireHash = true;
+        }
+    }
+    private synchronized void fillRackKey(final RubyString key) {
+        RackEnvironment.RACK_KEY rackKey = rackKeyMap.get(key);
+        if (rackKey != null) {
+            Object value = rackValues[rackKey.ordinal()];
+            if (value != null) {
+                if (value instanceof String) {
+                    boolean usAscii = usAsciiValues[rackKey.ordinal()];
+                    RubyString rubyValue = usAscii ? RubyHelper.toUsAsciiRubyString(getRuntime(), (String) value) :
+                            RubyHelper.toUnicodeRubyString(getRuntime(), (String) value);
+                    put(key, rubyValue);
+                } else {
+                    put(key, value);
+                }
+                rackValues[rackKey.ordinal()] = null;
+            }
+        }
+    }
+
+    private synchronized  void populateHeaderKeyMap() {
+        for (String key : headers.names()) {
+            byte[] rubyKeyBytes = rackHeaderNameToBytes(key);
+            RubyString rubyKey = RubyHelper.toUsAsciiRubyString(getRuntime(), rubyKeyBytes);
+            putHeaderKey(rubyKey, key);
+        }
+        this.filledHeaderKeyMap = true;
+    }
+
+    private void putHeaderKey(RubyString rubyKey, String key) {
+        this.headerKeyMap.put(rubyKey, key);
+    }
+    private synchronized void fillHeaderKey(final RubyString rubyKey) {
+        String headerKey = this.headerKeyMap.get(rubyKey);
+        if (headerKey != null) fillHeaderKey(rubyKey, headerKey);
+    }
+    private synchronized void fillHeaderKey(final RubyString rubyKey, String key) {
+        // RACK spec says not to create HTTP_CONTENT_TYPE or HTTP_CONTENT_LENGTH headers
+        if (!key.equals(HttpHeaders.Names.CONTENT_TYPE) && !key.equals(HttpHeaders.Names.CONTENT_LENGTH)) {
+            List<String> headerValues = headers.getAll(key);
+            if (!headerValues.isEmpty()) {
+                String headerValue = headerValues.get(0);
+                int valueIndex = 1;
+                while (valueIndex < headerValues.size()) {
+                    headerValue += "\n" + headerValues.get(valueIndex++);
+                }
+                put(rubyKey, RubyHelper.toUnicodeRubyString(getRuntime(), headerValue));
+            }
+        }
+    }
+
+    private static byte[] rackHeaderNameToBytes(final String headerName) {
+        // This is a more performant implemention of:
+        // "HTTP_" + headerName.toUpperCase().replace('-', '_');
+        byte[] envNameBytes = new byte[headerName.length() + 5];
+        envNameBytes[0] = 'H';
+        envNameBytes[1] = 'T';
+        envNameBytes[2] = 'T';
+        envNameBytes[3] = 'P';
+        envNameBytes[4] = '_';
+        for (int i = 5; i < envNameBytes.length; i++) {
+            envNameBytes[i] = (byte) rackHeaderize(headerName.charAt(i - 5));
+        }
+        return envNameBytes;
+    }
+
+    private static char rackHeaderize(char c) {
+        if (c == '-') {
+            c = '_';
+        }
+        return toUpperCase(c);
+    }
+
+    private static char toUpperCase(char c) {
+        if (c >= 'a' && c <= 'z') {
+            c -= 32;
+        }
+        return c;
+    }
+
+    private final Object[] rackValues = new Object[RackEnvironment.NUM_RACK_KEYS];
+    private final boolean[] usAsciiValues = new boolean[RackEnvironment.NUM_RACK_KEYS];
+    private final MultiMap headers;
+    private final Map<RubyString, RackEnvironment.RACK_KEY> rackKeyMap;
+    private final Map<RubyString, String> headerKeyMap;
+    private boolean filledEntireHash = false;
+    private boolean filledHeaderKeyMap = false;
+
+
+
+    //
+    // Overridden RubyHash methods that operate on individual keys
+    //
+    @Override
+    public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
+        fillKey(key);
+        return super.op_aref(context, key);
+    }
+    @Override
+    public IRubyObject fetch(ThreadContext context, IRubyObject key, Block block) {
+        fillKey(key);
+        return super.fetch(context, key, block);
+    }
+    @Override
+    public IRubyObject fetch(ThreadContext context, IRubyObject key, IRubyObject _default, Block block) {
+        fillKey(key);
+        return super.fetch(context, key ,_default, block);
+    }
+    @Override
+    public RubyBoolean has_key_p(IRubyObject key) {
+        fillKey(key);
+        return super.has_key_p(key);
+    }
+    @Override
+    public IRubyObject op_aset(ThreadContext context, IRubyObject key, IRubyObject value) {
+        fillKey(key);
+        return super.op_aset(context, key, value);
+    }
+    @Override
+    public IRubyObject delete(ThreadContext context, IRubyObject key, Block block) {
+        fillKey(key);
+        return super.delete(context, key, block);
+    }
+
+    //
+    // Overridden RubyHash methods that don't operate on individual keys so we
+    // fill the entire hash
+    //
+    @Override
+    public IRubyObject inspect(ThreadContext context) {
+        fillEntireHash();
+        return super.inspect(context);
+    }
+    @Override
+    public IRubyObject inspect19(ThreadContext context) {
+        fillEntireHash();
+        return super.inspect19(context);
+    }
+    @Override
+    public RubyFixnum rb_size() {
+        fillEntireHash();
+        return super.rb_size();
+    }
+    @Override
+    public RubyBoolean empty_p() {
+        fillEntireHash();
+        return super.empty_p();
+    }
+    @Override
+    public RubyArray to_a() {
+        fillEntireHash();
+        return super.to_a();
+    }
+    @Override
+    public IRubyObject to_s(ThreadContext context) {
+        fillEntireHash();
+        return super.to_s(context);
+    }
+    @Override
+    public IRubyObject to_s19(ThreadContext context) {
+        fillEntireHash();
+        return super.to_s19(context);
+    }
+    @Override
+    public RubyHash rehash() {
+        fillEntireHash();
+        return super.rehash();
+    }
+    @Override
+    public IRubyObject op_equal(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.op_equal(context, other);
+    }
+    @Override
+    public IRubyObject op_eql19(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.op_eql19(context, other);
+    }
+    @Override
+    public RubyFixnum hash() {
+        fillEntireHash();
+        return super.hash();
+    }
+    @Override
+    public RubyFixnum hash19() {
+        fillEntireHash();
+        return super.hash19();
+    }
+    @Override
+    public IRubyObject fetch(ThreadContext context, IRubyObject[] args, Block block) {
+        fillEntireHash();
+        return super.fetch(context, args, block);
+    }
+    @Override
+    public RubyBoolean has_value_p(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.has_value_p(context, expected);
+    }
+    @Override
+    public IRubyObject each(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each(context, block);
+    }
+    @Override
+    public IRubyObject each19(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each19(context, block);
+    }
+    @Override
+    public IRubyObject each_value(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each_value(context, block);
+    }
+    @Override
+    public IRubyObject each_key(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.each_key(context, block);
+    }
+    @Override
+    public IRubyObject select_bang(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.select_bang(context, block);
+    }
+    @Override
+    public IRubyObject keep_if(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.keep_if(context, block);
+    }
+    @Override
+    public IRubyObject sort(ThreadContext context, Block block) {
+        fillEntireHash();
+        return super.sort(context, block);
+    }
+    @Override
+    public IRubyObject index(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.index(context, expected);
+    }
+    @Override
+    public IRubyObject index19(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.index19(context, expected);
+    }
+    @Override
+    public IRubyObject key(ThreadContext context, IRubyObject expected) {
+        fillEntireHash();
+        return super.key(context, expected);
+    }
+    @Override
+    public RubyArray indices(ThreadContext context, IRubyObject[] indices) {
+        fillEntireHash();
+        return super.indices(context, indices);
+    }
+    @Override
+    public RubyArray keys() {
+        fillEntireHash();
+        return super.keys();
+    }
+    @Override
+    public RubyArray rb_values() {
+        fillEntireHash();
+        return super.rb_values();
+    }
+    @Override
+    public IRubyObject shift(ThreadContext context) {
+        fillEntireHash();
+        return super.shift(context);
+    }
+    @Override
+    public IRubyObject select(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.select(context, block);
+    }
+    @Override
+    public IRubyObject select19(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.select19(context, block);
+    }
+    @Override
+    public IRubyObject delete_if(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.delete_if(context, block);
+    }
+    @Override
+    public IRubyObject reject(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.reject(context, block);
+    }
+    @Override
+    public IRubyObject reject_bang(final ThreadContext context, final Block block) {
+        fillEntireHash();
+        return super.reject_bang(context, block);
+    }
+    @Override
+    public RubyHash rb_clear() {
+        fillEntireHash();
+        return super.rb_clear();
+    }
+    @Override
+    public RubyHash invert(final ThreadContext context) {
+        fillEntireHash();
+        return super.invert(context);
+    }
+    @Override
+    public RubyHash merge_bang(final ThreadContext context, final IRubyObject other, final Block block) {
+        fillEntireHash();
+        return super.merge_bang(context, other, block);
+    }
+    @Override
+    public RubyHash merge_bang19(final ThreadContext context, final IRubyObject other, final Block block) {
+        fillEntireHash();
+        return super.merge_bang19(context, other, block);
+    }
+    @Override
+    public RubyHash merge(ThreadContext context, IRubyObject other, Block block) {
+        fillEntireHash();
+        return super.merge(context, other, block);
+    }
+    @Override
+    public RubyHash initialize_copy(ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.initialize_copy(context, other);
+    }
+    @Override
+    public RubyHash initialize_copy19(ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.initialize_copy19(context, other);
+    }
+    @Override
+    public RubyHash replace(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.replace(context, other);
+    }
+    @Override
+    public RubyHash replace19(final ThreadContext context, IRubyObject other) {
+        fillEntireHash();
+        return super.replace19(context, other);
+    }
+    @Override
+    public RubyArray values_at(ThreadContext context, IRubyObject[] args) {
+        fillEntireHash();
+        return super.values_at(context, args);
+    }
+    @Override
+    public IRubyObject assoc(final ThreadContext context, final IRubyObject obj) {
+        fillEntireHash();
+        return super.assoc(context, obj);
+    }
+    @Override
+    public IRubyObject rassoc(final ThreadContext context, final IRubyObject obj) {
+        fillEntireHash();
+        return super.rassoc(context, obj);
+    }
+    @Override
+    public IRubyObject flatten(ThreadContext context) {
+        fillEntireHash();
+        return super.flatten(context);
+    }
+    @Override
+    public IRubyObject flatten(ThreadContext context, IRubyObject level) {
+        fillEntireHash();
+        return super.flatten(context, level);
+    }
+    @Override
+    public IRubyObject getCompareByIdentity(ThreadContext context) {
+        fillEntireHash();
+        return super.getCompareByIdentity(context);
+    }
+    @Override
+    public IRubyObject getCompareByIdentity_p(ThreadContext context) {
+        fillEntireHash();
+        return super.getCompareByIdentity_p(context);
+    }
+    @Override
+    public IRubyObject dup(ThreadContext context) {
+        fillEntireHash();
+        return super.dup(context);
+    }
+    @Override
+    public IRubyObject rbClone(ThreadContext context) {
+        fillEntireHash();
+        return super.rbClone(context);
+    }
+}