jubilee 2.1.0.Alpha1-java → 2.1.0.beta-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 683724968b6ea7ae25e8fcb25f3684bc65df6a47
-  data.tar.gz: 92f9f51d3833a0b228bc22f49cdcd07a4d2a02f2
+  metadata.gz: 865bcd4759e0b52c639ae642a749f1885da1025c
+  data.tar.gz: 7a13f948d9e4a4a75ee039b1765b74ea9333c3b6
 SHA512:
-  metadata.gz: e9a114e152bc837ab4ce9d8ab2759cf7edcc9f2f79e40871c3e8c8b4d0489d08b29eb8bfcafc74318e13025a4d5d6c60a2350cdc4e3670096f90c96842b84a70
-  data.tar.gz: 9de31bb5904dc1ff30d37bb2f081bb451dd024819f1a758594514839e68d0cf1d47f836d35438ade2993126dd655a00d8f5f8effbc077cb0ee935afde57f09e0
+  metadata.gz: ba572a6a03c0c8c593d6f183375c8aa42fa69c10fe5c41b9d50fd9f0d7360f7ad3a71201ee7dd695a4ee5c1ddfac98b77d5ed3727cec2e68c7e4a8d63c1d3757
+  data.tar.gz: 7e209e4e8a9d0e24599078aa550b2a74c57e1a4f7a8d1961d9fcb67faf1c403301d29436dcfb0c582402a69fc6bff6883c50a6e61482f01f6f947e23efa3a2ae

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
-  - jruby-19mode # JRuby in 1.9 mode
+  - jruby-19mode
 
-script: "bundle exec rake spec"
+script: "bundle exec rake test spec"

data/CHANGELOG

@@ -1,3 +1,12 @@
+Release 2.1.0
+=============
+
+#4 rack.hijack support
+
+Release 2.0.0
+=============
+support multiple instances of web servers
+
 Release 1.1.1
 =============
 

data/README.md

@@ -52,18 +52,23 @@ Get started
 Setup
 -----
 
-If you use bundler, you might want to add `jubilee` to your Gemfile,
-this is also required if you want use rails http streaming,
+If you use bundler, you might want to add `jubilee` to your Gemfile
 
-    $ jubilee
+    gem 'jubilee', '~> 2.0.0'
 
-or if you prefer to use the rack handler(e.g. development) use:
+Rails
+-----
+
+Under the default setup, jubilee runs 4 instances of web
+servers, each with it's own jruby runtime, if you find that jubilee
+crashes or hangs with OutOfMemeoryError, please tune your JVM OPTS
+like this:
 
-    $ rails s jubilee
+    $ export JAVA_OPTS="-Xms1024m -Xmx2048m -XX:PermSize=512m -XX:MaxPermSize=512m"
 
-or
+If your OS memory is quite limited, please run jubilee with
 
-    $ rackup -s jubilee
+    $ jubilee -n 1
 
 Event Bus
 =========

data/java/src/jubilee/JubileeService.java

@@ -2,8 +2,8 @@ package jubilee;
 
 import org.jruby.Ruby;
 import org.jruby.jubilee.RubyHttpServerResponse;
+import org.jruby.jubilee.RubyNetSocket;
 import org.jruby.jubilee.RubyPlatformManager;
-import org.jruby.jubilee.RubyServer;
 import org.jruby.jubilee.impl.RubyIORackInput;
 import org.jruby.jubilee.impl.RubyNullIO;
 import org.jruby.runtime.load.BasicLibraryService;
@@ -12,11 +12,11 @@ import java.io.IOException;
 
 public class JubileeService implements BasicLibraryService {
     public boolean basicLoad(final Ruby ruby) throws IOException {
-        RubyServer.createServerClass(ruby);
         RubyHttpServerResponse.createHttpServerResponseClass(ruby);
         RubyIORackInput.createIORackInputClass(ruby);
         RubyNullIO.createNullIOClass(ruby);
-      RubyPlatformManager.createPlatformManagerClass(ruby);
+        RubyNetSocket.createNetSocketClass(ruby);
+        RubyPlatformManager.createPlatformManagerClass(ruby);
         return true;
     }
 }

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

@@ -8,7 +8,7 @@ package org.jruby.jubilee;
  */
 public final class Const {
 
-    public static final String JUBILEE_VERSION = "Jubilee(2.0.0)";
+    public static final String JUBILEE_VERSION = "Jubilee(2.1.0)";
     public static final String HTTP_11 = "HTTP/1.1";
     public static final String HTTP_10 = "HTTP/1.0";
 

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

@@ -1,7 +1,9 @@
 package org.jruby.jubilee;
 
 import org.jruby.Ruby;
+import org.jruby.RubyArray;
 import org.jruby.RubyInstanceConfig;
+import org.jruby.RubyString;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.vertx.java.core.Handler;
 import org.vertx.java.core.http.HttpServer;
@@ -12,13 +14,14 @@ import org.vertx.java.platform.Verticle;
 import org.vertx.java.platform.impl.WrappedVertx;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
 /**
  * Created by isaiah on 23/01/2014.
  */
 public class JubileeVerticle extends Verticle {
-    private Ruby runtime;
 
     @Override
     public void start() {
@@ -32,7 +35,7 @@ public class JubileeVerticle extends Verticle {
         final RackApplication app;
         boolean ssl = config.getBoolean("ssl");
         try {
-            app = new RackApplication((WrappedVertx) vertx, runtime.getCurrentContext(), rackApplication, ssl);
+            app = new RackApplication((WrappedVertx) vertx, runtime.getCurrentContext(), rackApplication, config);
             httpServer.setAcceptBacklog(10000);
             httpServer.requestHandler(new Handler<HttpServerRequest>() {
                 public void handle(final HttpServerRequest req) {
@@ -59,6 +62,10 @@ public class JubileeVerticle extends Verticle {
         this.runtime.tearDown();
     }
 
+    public void setClassLoader(ClassLoader classLoader) {
+        this.classLoader = classLoader;
+    }
+
     private Ruby createRuntime(String root, JsonObject options) {
         Ruby runtime;
 //        if (Ruby.isGlobalRuntimeReady()) {
@@ -71,9 +78,17 @@ public class JubileeVerticle extends Verticle {
         }
         Object[] argv = options.getArray("argv", new JsonArray(new String[]{})).toArray();
         instanceConfig.setArgv(Arrays.copyOf(argv, argv.length, String[].class));
-        runtime = Ruby.newInstance(instanceConfig);
 //        }
-        runtime.getLoadService().addPaths(root);
+        RubyArray globalLoadPaths = (RubyArray) Ruby.getGlobalRuntime().getLoadService().getLoadPath();
+        List<String> loadPaths = new ArrayList<>();
+        for (int i = 0; i < globalLoadPaths.size(); i++) {
+            IRubyObject entry = globalLoadPaths.eltInternal(i);
+            loadPaths.add(entry.asJavaString());
+        }
+        instanceConfig.setLoadPaths(loadPaths);
+
+        instanceConfig.setLoader(getClassLoader());
+        runtime = Ruby.newInstance(instanceConfig);
         return runtime;
     }
 
@@ -89,4 +104,14 @@ public class JubileeVerticle extends Verticle {
         rackScript += "Jubilee::Application.new(app)\n";
         return runtime.evalScriptlet(rackScript);
     }
+
+    private ClassLoader getClassLoader() {
+        if (this.classLoader != null) return this.classLoader;
+        ClassLoader cl = Thread.currentThread().getContextClassLoader();
+        if (cl != null) return cl;
+        return getClass().getClassLoader();
+    }
+
+    private Ruby runtime;
+    private ClassLoader classLoader;
 }

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

@@ -6,18 +6,16 @@ import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyFixnum;
-import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.jubilee.impl.RubyIORackInput;
 import org.jruby.jubilee.impl.RubyNullIO;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.vertx.java.core.Handler;
-import org.vertx.java.core.Vertx;
 import org.vertx.java.core.VoidHandler;
 import org.vertx.java.core.buffer.Buffer;
 import org.vertx.java.core.http.HttpServerRequest;
-import org.vertx.java.core.impl.DefaultVertx;
+import org.vertx.java.core.json.JsonObject;
 import org.vertx.java.platform.impl.WrappedVertx;
 
 import java.io.IOException;
@@ -34,24 +32,22 @@ import java.util.concurrent.atomic.AtomicBoolean;
 public class RackApplication {
     private IRubyObject app;
     private boolean ssl;
+    private boolean hideErrorStack;
     private Ruby runtime;
     private WrappedVertx vertx;
     private RubyClass rackIOInputClass;
     private RubyClass httpServerResponseClass;
-    private RubyArray rackVersion;
-    private RubyNullIO nullio;
     private RackEnvironment rackEnv;
 
-    public RackApplication(WrappedVertx vertx, ThreadContext context, IRubyObject app, boolean ssl) throws IOException {
+    public RackApplication(WrappedVertx vertx, ThreadContext context, IRubyObject app, JsonObject config) throws IOException {
         this.app = app;
-        this.ssl = ssl;
+        this.ssl = config.getBoolean("ssl");
+        this.hideErrorStack = config.getBoolean("hide_error_stack", false);
         this.vertx = vertx;
         this.runtime = context.runtime;
-        this.rackVersion = RubyArray.newArrayLight(runtime, RubyFixnum.one(runtime), RubyFixnum.four(runtime));
         // Memorize the ruby classes
         this.rackIOInputClass = (RubyClass) runtime.getClassFromPath("Jubilee::IORackInput");
         this.httpServerResponseClass = (RubyClass) runtime.getClassFromPath("Jubilee::HttpServerResponse");
-        this.nullio = new RubyNullIO(runtime, (RubyClass) runtime.getClassFromPath("Jubilee::NullIO"));
 
         this.rackEnv = new RackEnvironment(runtime);
     }
@@ -64,23 +60,23 @@ public class RackApplication {
         // it set the empty content flag when passing the header
 //        if ((te != null && te.equals("chunked")) ||
 //                ((contentLength = request.headers().get(Const.Vertx.CONTENT_LENGTH)) != null && !contentLength.equals("0"))) {
-            final ByteBuf bodyBuf = Unpooled.buffer(0, Integer.MAX_VALUE);
-            final AtomicBoolean eof = new AtomicBoolean(false);
-            input = new RubyIORackInput(runtime, rackIOInputClass, request, bodyBuf, eof);
+        final ByteBuf bodyBuf = Unpooled.buffer(0, Integer.MAX_VALUE);
+        final AtomicBoolean eof = new AtomicBoolean(false);
+        input = new RubyIORackInput(runtime, rackIOInputClass, request, bodyBuf, eof);
 
-            request.dataHandler(new Handler<Buffer>() {
-                @Override
-                public void handle(Buffer buffer) {
-                    bodyBuf.writeBytes(buffer.getByteBuf());
-                }
-            });
+        request.dataHandler(new Handler<Buffer>() {
+            @Override
+            public void handle(Buffer buffer) {
+                bodyBuf.writeBytes(buffer.getByteBuf());
+            }
+        });
 
-            request.endHandler(new VoidHandler() {
-                @Override
-                protected void handle() {
-                    eof.set(true);
-                }
-            });
+        request.endHandler(new VoidHandler() {
+            @Override
+            protected void handle() {
+                eof.set(true);
+            }
+        });
         request.exceptionHandler(new Handler<Throwable>() {
             @Override
             public void handle(Throwable ignore) {
@@ -94,21 +90,28 @@ public class RackApplication {
             @Override
             public void run() {
                 try {
-                  // This is a different context, do NOT replace runtime.getCurrentContext()
-                  IRubyObject result = app.callMethod(runtime.getCurrentContext(), "call", rackEnv.getEnv(request, input, ssl));
+                    // This is a different context, do NOT replace runtime.getCurrentContext()
+                    IRubyObject result = app.callMethod(runtime.getCurrentContext(), "call", rackEnv.getEnv(request, input, ssl));
+                    if (request.isHijacked()) {
+                        // It's the hijacker's response to close the socket.
+                        return;
+                    }
                     RackResponse response = (RackResponse) JavaEmbedUtils.rubyToJava(runtime, result, RackResponse.class);
                     RubyHttpServerResponse resp = new RubyHttpServerResponse(runtime,
-                            httpServerResponseClass,
-                            request.response());
+                            httpServerResponseClass, request);
                     response.respond(resp);
                 } catch (Exception e) {
-                  request.response().setStatusCode(500);
-                  String message = "Jubilee caught this error: " + e.getMessage() + "\n";
-                  StringWriter stringWriter = new StringWriter();
-                  PrintWriter printWriter = new PrintWriter(stringWriter);
-                  e.printStackTrace(printWriter);
-                  request.response().end(message + stringWriter.toString());
-                  e.printStackTrace(runtime.getErrorStream());
+                    request.response().setStatusCode(500);
+                    String message = "Jubilee caught this error: " + e.getMessage() + "\n";
+                    StringWriter stringWriter = new StringWriter();
+                    PrintWriter printWriter = new PrintWriter(stringWriter);
+                    e.printStackTrace(printWriter);
+                    if (hideErrorStack) {
+                        request.response().end("Internal error.");
+                    } else {
+                        request.response().end(message + stringWriter.toString());
+                    }
+                    e.printStackTrace(runtime.getErrorStream());
                 }
             }
         };

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

@@ -1,17 +1,14 @@
 package org.jruby.jubilee;
 
 import io.netty.handler.codec.http.HttpHeaders;
-import org.jruby.Ruby;
-import org.jruby.RubyArray;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyHash;
-import org.jruby.RubyIO;
-import org.jruby.RubyString;
-
+import org.jruby.*;
 import org.jruby.jubilee.utils.RubyHelper;
+import org.jruby.runtime.*;
+import org.jruby.runtime.builtin.IRubyObject;
 import org.vertx.java.core.MultiMap;
 import org.vertx.java.core.http.HttpServerRequest;
 import org.vertx.java.core.http.HttpVersion;
+import org.vertx.java.core.net.NetSocket;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -27,12 +24,14 @@ public class RackEnvironment {
         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
+        HTTPS, HTTP_VERSION, HIJACK_P, HIJACK//, HIJACK_IO
     }
+
     static final int NUM_RACK_KEYS = RACK_KEY.values().length;
 
     public RackEnvironment(final Ruby runtime) throws IOException {
         this.runtime = runtime;
+        this.netSocketClass = (RubyClass) runtime.getClassFromPath("Jubilee::NetSocket");
         rackVersion = RubyArray.newArray(runtime, RubyFixnum.one(runtime), RubyFixnum.four(runtime));
         errors = new RubyIO(runtime, runtime.getErr());
         errors.setAutoclose(false);
@@ -58,6 +57,10 @@ public class RackEnvironment {
         putRack("rack.multithread", RACK_KEY.MULTITHREAD);
         putRack("rack.multiprocess", RACK_KEY.MULTIPROCESS);
         putRack("rack.run_once", RACK_KEY.RUN_ONCE);
+        putRack("rack.hijack?", RACK_KEY.HIJACK_P);
+        putRack("rack.hijack", RACK_KEY.HIJACK);
+        // putRack("rack.hijack_io", RACK_KEY.HIJACK_IO); Don't have to be lazy, since once rack.hijack is called, the io
+        // object has to be required by the caller.
         putRack("CONTENT_LENGTH", RACK_KEY.CONTENT_LENGTH);
         putRack("HTTPS", RACK_KEY.HTTPS);
     }
@@ -90,12 +93,17 @@ public class RackEnvironment {
         env.lazyPut(RACK_KEY.CONTENT_TYPE, headers.get(HttpHeaders.Names.CONTENT_TYPE), true);
         env.lazyPut(RACK_KEY.REQUEST_URI, request.uri(), 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.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);
 
+        // Hijack handling
+        env.lazyPut(RACK_KEY.HIJACK_P, runtime.getTrue(), false);
+        env.lazyPut(RACK_KEY.HIJACK, hijackProc(env, request), false);
+
+
         final int contentLength = getContentLength(headers);
         if (contentLength >= 0) {
             env.lazyPut(RACK_KEY.CONTENT_LENGTH, contentLength + "", true);
@@ -108,24 +116,49 @@ public class RackEnvironment {
         return env;
     }
 
+    private IRubyObject hijackProc(final RackEnvironmentHash env, final HttpServerRequest req) {
+        CompiledBlockCallback19 callback = new CompiledBlockCallback19() {
+            @Override
+            public IRubyObject call(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) {
+                RubyNetSocket rubyNetSocket = new RubyNetSocket(context.runtime, netSocketClass, req.netSocket());
+                env.put("rack.hijack_io", rubyNetSocket);
+                return rubyNetSocket;
+            }
+
+            @Override
+            public String getFile() {
+                return null;
+            }
+
+            @Override
+            public int getLine() {
+                return 0;
+            }
+        };
+        BlockBody body = CompiledBlockLight19.newCompiledBlockLight(Arity.NO_ARGUMENTS, runtime.getStaticScopeFactory().getDummyScope(), callback, false, 0, new String[]{});
+        Block b = new Block(body, runtime.newBinding().getBinding());
+
+        return RubyProc.newProc(runtime, b, Block.Type.LAMBDA);
+    }
+
     public String[] getHostInfo(String host) {
-      String[] hostInfo;
-      if (host != null) {
-        int colon = host.indexOf(":");
-        if (colon > 0)
-          hostInfo = new String[]{host.substring(0, colon), host.substring(colon + 1)};
-        else
-          hostInfo = new String[]{host, Const.PORT_80};
-
-      } else {
-        hostInfo = new String[]{Const.LOCALHOST, Const.PORT_80};
-      }
-      return hostInfo;
+        String[] hostInfo;
+        if (host != null) {
+            int colon = host.indexOf(":");
+            if (colon > 0)
+                hostInfo = new String[]{host.substring(0, colon), host.substring(colon + 1)};
+            else
+                hostInfo = new String[]{host, Const.PORT_80};
+
+        } else {
+            hostInfo = new String[]{Const.LOCALHOST, Const.PORT_80};
+        }
+        return hostInfo;
     }
 
     private static String getRemoteAddr(final HttpServerRequest request) {
         InetSocketAddress sourceAddress = request.remoteAddress();
-        if(sourceAddress == null) {
+        if (sourceAddress == null) {
             return "";
         }
         return sourceAddress.getHostString();
@@ -147,4 +180,5 @@ public class RackEnvironment {
     private final RubyArray rackVersion;
     private final RubyIO errors;
     private final Map<RubyString, RACK_KEY> rackKeyMap = new HashMap<>();
-}
+    private final RubyClass netSocketClass;
+}

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

@@ -1,16 +1,11 @@
 package org.jruby.jubilee;
 
 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.*;
+import org.jruby.jubilee.utils.RubyHelper;
 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;
@@ -38,7 +33,7 @@ public class RackEnvironmentHash extends RubyHash {
     private synchronized void fillKey(final IRubyObject rubyKey) {
         if (!filledEntireHash) {
             if (rubyKey instanceof RubyString && !containsKey(rubyKey)) {
-                if (! filledHeaderKeyMap) populateHeaderKeyMap();
+                if (!filledHeaderKeyMap) populateHeaderKeyMap();
                 byte[] keyBytes = ((RubyString) rubyKey).getBytes();
                 if (keyBytes.length > 5 && keyBytes[0] == 'H'
                         && keyBytes[1] == 'T' && keyBytes[2] == 'T'
@@ -51,6 +46,7 @@ public class RackEnvironmentHash extends RubyHash {
             }
         }
     }
+
     private synchronized void fillEntireHash() {
         if (!filledEntireHash) {
             for (RubyString key : rackKeyMap.keySet()) {
@@ -65,6 +61,7 @@ public class RackEnvironmentHash extends RubyHash {
             filledEntireHash = true;
         }
     }
+
     private synchronized void fillRackKey(final RubyString key) {
         RackEnvironment.RACK_KEY rackKey = rackKeyMap.get(key);
         if (rackKey != null) {
@@ -83,7 +80,7 @@ public class RackEnvironmentHash extends RubyHash {
         }
     }
 
-    private synchronized  void populateHeaderKeyMap() {
+    private synchronized void populateHeaderKeyMap() {
         for (String key : headers.names()) {
             byte[] rubyKeyBytes = rackHeaderNameToBytes(key);
             RubyString rubyKey = RubyHelper.toUsAsciiRubyString(getRuntime(), rubyKeyBytes);
@@ -95,10 +92,12 @@ public class RackEnvironmentHash extends RubyHash {
     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)) {
@@ -152,7 +151,6 @@ public class RackEnvironmentHash extends RubyHash {
     private boolean filledHeaderKeyMap = false;
 
 
-
     //
     // Overridden RubyHash methods that operate on individual keys
     //
@@ -161,26 +159,31 @@ public class RackEnvironmentHash extends RubyHash {
         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);
+        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);
@@ -196,251 +199,301 @@ public class RackEnvironmentHash extends RubyHash {
         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();