[chore] Add missing override declarations

chadlwilson · chadlwilson · commit 19200d1318b7 · 2025-08-19T12:59:59.000+08:00
(cherry picked from commit c5e6b58) # Conflicts: # src/main/java/org/jruby/rack/DefaultErrorApplication.java # src/main/java/org/jruby/rack/embed/Config.java # src/main/java/org/jruby/rack/servlet/RequestCapture.java
diff --git a/src/main/java/org/jruby/rack/AbstractFilter.java b/src/main/java/org/jruby/rack/AbstractFilter.java
@@ -8,7 +8,6 @@
 package org.jruby.rack;
 
 import java.io.IOException;
-
 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.ServletException;
@@ -48,6 +47,7 @@ public abstract class AbstractFilter implements Filter {
      * @throws IOException if there's an IO exception
      * @throws ServletException if there's a servlet exception
      */
+    @Override
     public final void doFilter(
             ServletRequest request, ServletResponse response,
             FilterChain chain) throws IOException, ServletException {
diff --git a/src/main/java/org/jruby/rack/AbstractRackDispatcher.java b/src/main/java/org/jruby/rack/AbstractRackDispatcher.java
@@ -24,6 +24,7 @@ public AbstractRackDispatcher(RackContext context) {
         this.context = context;
     }
 
+    @Override
     public void process(RackEnvironment request, RackResponseEnvironment response)
         throws IOException {
 
diff --git a/src/main/java/org/jruby/rack/DefaultErrorApplication.java b/src/main/java/org/jruby/rack/DefaultErrorApplication.java
@@ -60,14 +60,6 @@ public Ruby getRuntime() {
         throw new UnsupportedOperationException("getRuntime() not supported");
     }
 
-    public void init() {
-        // NOOP
-    }
-
-    public void destroy() {
-        // NOOP
-    }
-
     @Override
     public RackResponse call(RackEnvironment env) throws RackException {
         return new Response(env); // backwards compatibility
@@ -92,6 +84,7 @@ private class Response implements RackResponse {
 
         public Response(RackEnvironment env) { this.env = env; }
 
+        @Override
         public int getStatus() {
             return status;
         }
@@ -101,6 +94,7 @@ public void setStatus(int status) {
             this.status = status;
         }
 
+        @Override
         @SuppressWarnings("rawtypes")
         public Map getHeaders() {
             return headers;
@@ -111,6 +105,7 @@ public void setHeaders(@SuppressWarnings("rawtypes") Map headers) {
             this.headers = headers == null ? Collections.EMPTY_MAP : headers;
         }
 
+        @Override
         public String getBody() {
             if ( body == null ) {
                 try {
@@ -144,6 +139,7 @@ protected String buildErrorBody() {
             return stringWriter.toString();
         }
 
+        @Override
         public void respond(RackResponseEnvironment response) {
             try {
                 defaultRespond(this, response);
diff --git a/src/main/java/org/jruby/rack/DefaultRackApplicationFactory.java b/src/main/java/org/jruby/rack/DefaultRackApplicationFactory.java
@@ -101,6 +101,7 @@ public void init(final RackContext rackContext) {
     @Override
     public RackApplication newApplication() {
         return createApplication(new ApplicationObjectFactory() {
+            @Override
             public IRubyObject create(Ruby runtime) {
                 return createApplicationObject(runtime);
             }
@@ -212,6 +213,7 @@ public RackApplication newErrorApplication() {
         try {
             RackApplication app = createErrorApplication(
                 new ApplicationObjectFactory() {
+                    @Override
                     public IRubyObject create(Ruby runtime) {
                         return createErrorApplicationObject(runtime);
                     }
diff --git a/src/main/java/org/jruby/rack/ErrorApplicationHandler.java b/src/main/java/org/jruby/rack/ErrorApplicationHandler.java
@@ -59,15 +59,19 @@ public void setError(Exception error) {
         this.error = error;
     }
 
+    @Override
     public RackResponse call(final RackEnvironment env) {
         env.setAttribute(RackEnvironment.EXCEPTION, getError());
         return getErrorApplication().call(env);
     }
 
+    @Override
     public void init() { getErrorApplication().init(); }
 
+    @Override
     public void destroy() { getErrorApplication().destroy(); }
 
+    @Override
     public Ruby getRuntime() {
         return getErrorApplication().getRuntime();
     }
diff --git a/src/main/java/org/jruby/rack/embed/Config.java b/src/main/java/org/jruby/rack/embed/Config.java
@@ -61,25 +61,6 @@ public String getProperty(String key, String defaultValue) {
         };
     }
 
-    /*
-    Config(final RackConfig config) {
-        delegate = new DefaultRackConfig() {
-
-            @Override
-            public String getProperty(String key, String defaultValue) {
-                String value = config.getProperty(key, null);
-                if ( value != null ) return value;
-
-                value = Config.this.resolveProperty(key);
-                return value != null ? value : super.getProperty(key, defaultValue);
-            }
-
-            @Override
-            public RackLogger defaultLogger() { return null; }
-
-        };
-    } */
-
     @SuppressWarnings("unchecked")
     public void doInitialize(final Ruby runtime) {
         setOut( runtime.getOut() );
@@ -95,34 +76,42 @@ protected String resolveProperty(String key) {
         return value;
     }
 
+    @Override
     public final String getProperty(String key) {
         return delegate.getProperty(key);
     }
 
+    @Override
     public final String getProperty(String key, String defaultValue) {
         return delegate.getProperty(key, defaultValue);
     }
 
+    @Override
     public final Boolean getBooleanProperty(String key) {
         return delegate.getBooleanProperty(key);
     }
 
+    @Override
     public final Boolean getBooleanProperty(String key, Boolean defaultValue) {
         return delegate.getBooleanProperty(key, defaultValue);
     }
 
+    @Override
     public final Number getNumberProperty(String key) {
         return delegate.getNumberProperty(key);
     }
 
+    @Override
     public final Number getNumberProperty(String key, Number defaultValue) {
         return delegate.getNumberProperty(key, defaultValue);
     }
 
+    @Override
     public CompatVersion getCompatVersion() {
         return compatVersion;
     }
 
+    @Override
     public RackLogger getLogger() {
         if (logger == null) {
             logger = delegate.getLogger();
@@ -134,6 +123,7 @@ public void setLogger(RackLogger logger) {
         this.logger = logger;
     }
 
+    @Override
     public PrintStream getOut() {
         return delegate.getOut();
     }
@@ -142,6 +132,7 @@ public void setOut(OutputStream out) {
         delegate.setOut(out);
     }
 
+    @Override
     public PrintStream getErr() {
         return delegate.getErr();
     }
@@ -150,76 +141,93 @@ public void setErr(OutputStream err) {
         delegate.setErr(err);
     }
 
+    @Override
     public boolean isRewindable() {
         return delegate.isRewindable();
     }
 
+    @Override
     public Integer getInitialMemoryBufferSize() {
         return delegate.getInitialMemoryBufferSize();
     }
 
+    @Override
     public Integer getMaximumMemoryBufferSize() {
         return delegate.getMaximumMemoryBufferSize();
     }
 
+    @Override
     public String getRackup() {
         return delegate.getRackup();
     }
 
+    @Override
     public String getRackupPath() {
         return delegate.getRackupPath();
     }
 
     // runtime pooling in embedded ENVs not implemented :
 
+    @Override
     public Integer getRuntimeTimeoutSeconds() {
         throw new UnsupportedOperationException("getRuntimeTimeoutSeconds()");
     }
 
+    @Override
     public Integer getInitialRuntimes() {
         throw new UnsupportedOperationException("getInitialRuntimes()");
     }
 
+    @Override
     public Integer getMaximumRuntimes() {
         throw new UnsupportedOperationException("getMaximumRuntimes()");
     }
 
+    @Override
     public String[] getRuntimeArguments() {
         throw new UnsupportedOperationException("getRuntimeArguments()");
     }
 
+    @Override
     public Integer getNumInitializerThreads() {
         throw new UnsupportedOperationException("getNumInitializerThreads()");
     }
 
+    @Override
     public boolean isSerialInitialization() {
         throw new UnsupportedOperationException("isSerialInitialization()");
     }
 
+    @Override
     public boolean isIgnoreEnvironment() {
         throw new UnsupportedOperationException("isIgnoreEnvironment()");
     }
 
+    @Override
     public Map<String, String> getRuntimeEnvironment() {
         throw new UnsupportedOperationException("getRuntimeEnvironment()");
     }
 
     // RackFilter aint's used with embed :
 
+    @Override
     public boolean isFilterAddsHtml() {
         throw new UnsupportedOperationException("isFilterAddsHtml()");
     }
 
+    @Override
     public boolean isFilterVerifiesResource() {
         throw new UnsupportedOperationException("isFilterVerifiesResource()");
     }
 
     // JMS configuration not used with embed :
 
+    @Override
     public String getJmsConnectionFactory() {
         throw new UnsupportedOperationException("getJmsConnectionFactory()");
     }
 
+    @Override
     public String getJmsJndiProperties() {
         throw new UnsupportedOperationException("getJmsJndiProperties()");
     }
diff --git a/src/main/java/org/jruby/rack/ext/Input.java b/src/main/java/org/jruby/rack/ext/Input.java
@@ -23,16 +23,15 @@
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.javasupport.JavaEmbedUtils;
+import org.jruby.rack.RackEnvironment;
+import org.jruby.rack.servlet.RewindableInputStream;
+import org.jruby.rack.util.ExceptionUtils;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.Helpers;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
-
-import org.jruby.rack.RackEnvironment;
-import org.jruby.rack.servlet.RewindableInputStream;
-import org.jruby.rack.util.ExceptionUtils;
 import org.jruby.util.StringSupport;
 
 /**
@@ -63,6 +62,7 @@ public class Input extends RubyObject {
     }
 
     static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
             return new Input(runtime, klass);
         }
diff --git a/src/main/java/org/jruby/rack/ext/Logger.java b/src/main/java/org/jruby/rack/ext/Logger.java
@@ -56,6 +56,7 @@
 public class Logger extends RubyObject { // implements RackLogger
 
     static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
             return new Logger(runtime, klass);
         }
@@ -542,6 +543,7 @@ public IRubyObject stub(final ThreadContext context) {
     public static class ServletLog extends RubyObject {
 
         static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+            @Override
             public IRubyObject allocate(Ruby runtime, RubyClass klass) {
                 return new ServletLog(runtime, klass);
             }
diff --git a/src/main/java/org/jruby/rack/ext/Response.java b/src/main/java/org/jruby/rack/ext/Response.java
@@ -210,6 +210,7 @@ public static IRubyObject set_channel_buffer_size(final IRubyObject self, final
     }
 
     static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
             return new Response(runtime, klass);
         }
@@ -274,6 +275,7 @@ public IRubyObject headers(final ThreadContext context) {
      * @return the response status
      * @see RackResponse#getStatus()
      */
+    @Override
     public int getStatus() {
         return this.status;
     }
@@ -282,6 +284,7 @@ public int getStatus() {
      * @return the headers hash
      * @see RackResponse#getHeaders()
      */
+    @Override
     @SuppressWarnings("unchecked")
     public Map<String, ?> getHeaders() {
         return this.headers;
@@ -291,6 +294,7 @@ public int getStatus() {
      * @return the response body (build up as a string)
      * @see RackResponse#getBody()
      */
+    @Override
     public String getBody() {
         if ( this.body instanceof RubyString ) return this.body.asJavaString();
         // body = ""; @body.each { |part| body << part }; body
@@ -324,6 +328,7 @@ public IRubyObject yield(ThreadContext context, IRubyObject part) {
      * Respond this response with the given (servlet) response environment.
      * @see RackResponse#respond(RackResponseEnvironment)
      */
+    @Override
     public void respond(final RackResponseEnvironment response) throws RackException {
         if ( ! response.isCommitted() ) {
             try { // NOTE: we're assuming possible overrides are out of our NS
diff --git a/src/main/java/org/jruby/rack/ext/Servlet.java b/src/main/java/org/jruby/rack/ext/Servlet.java
@@ -42,6 +42,7 @@
 public class Servlet extends RubyObject {
 
     static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
             return new Servlet(runtime, klass);
         }
diff --git a/src/main/java/org/jruby/rack/jms/DefaultQueueManager.java b/src/main/java/org/jruby/rack/jms/DefaultQueueManager.java
diff --git a/src/main/java/org/jruby/rack/jms/QueueContextListener.java b/src/main/java/org/jruby/rack/jms/QueueContextListener.java
diff --git a/src/main/java/org/jruby/rack/servlet/RequestCapture.java b/src/main/java/org/jruby/rack/servlet/RequestCapture.java
diff --git a/src/main/java/org/jruby/rack/servlet/ResponseCapture.java b/src/main/java/org/jruby/rack/servlet/ResponseCapture.java
diff --git a/src/main/java/org/jruby/rack/servlet/ServletRackResponseEnvironment.java b/src/main/java/org/jruby/rack/servlet/ServletRackResponseEnvironment.java

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ public AbstractRackDispatcher(RackContext context) {`
`24`	`24`	`this.context = context;`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ @Override`
`27`	`28`	`public void process(RackEnvironment request, RackResponseEnvironment response)`
`28`	`29`	`throws IOException {`
`29`	`30`
Original file line number	Diff line number	Diff line change
`@@ -59,15 +59,19 @@ public void setError(Exception error) {`
`59`	`59`	`this.error = error;`
`60`	`60`	`}`
`61`	`61`
	`62`	`+ @Override`
`62`	`63`	`public RackResponse call(final RackEnvironment env) {`
`63`	`64`	`env.setAttribute(RackEnvironment.EXCEPTION, getError());`
`64`	`65`	`return getErrorApplication().call(env);`
`65`	`66`	`}`
`66`	`67`
	`68`	`+ @Override`
`67`	`69`	`public void init() { getErrorApplication().init(); }`
`68`	`70`
	`71`	`+ @Override`
`69`	`72`	`public void destroy() { getErrorApplication().destroy(); }`
`70`	`73`
	`74`	`+ @Override`
`71`	`75`	`public Ruby getRuntime() {`
`72`	`76`	`return getErrorApplication().getRuntime();`
`73`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,25 +61,6 @@ public String getProperty(String key, String defaultValue) {`
`61`	`61`	`};`
`62`	`62`	`}`
`63`	`63`
`64`		`- /*`
`65`		`- Config(final RackConfig config) {`
`66`		`- delegate = new DefaultRackConfig() {`
`67`		`-`
`68`		`- @Override`
`69`		`- public String getProperty(String key, String defaultValue) {`
`70`		`- String value = config.getProperty(key, null);`
`71`		`- if ( value != null ) return value;`
`72`		`-`
`73`		`- value = Config.this.resolveProperty(key);`
`74`		`- return value != null ? value : super.getProperty(key, defaultValue);`
`75`		`- }`
`76`		`-`
`77`		`- @Override`
`78`		`- public RackLogger defaultLogger() { return null; }`
`79`		`-`
`80`		`- };`
`81`		`- } */`
`82`		`-`
`83`	`64`	`@SuppressWarnings("unchecked")`
`84`	`65`	`public void doInitialize(final Ruby runtime) {`
`85`	`66`	`setOut( runtime.getOut() );`
`@@ -95,34 +76,42 @@ protected String resolveProperty(String key) {`
`95`	`76`	`return value;`
`96`	`77`	`}`
`97`	`78`
	`79`	`+ @Override`
`98`	`80`	`public final String getProperty(String key) {`
`99`	`81`	`return delegate.getProperty(key);`
`100`	`82`	`}`
`101`	`83`
	`84`	`+ @Override`
`102`	`85`	`public final String getProperty(String key, String defaultValue) {`
`103`	`86`	`return delegate.getProperty(key, defaultValue);`
`104`	`87`	`}`
`105`	`88`
	`89`	`+ @Override`
`106`	`90`	`public final Boolean getBooleanProperty(String key) {`
`107`	`91`	`return delegate.getBooleanProperty(key);`
`108`	`92`	`}`
`109`	`93`
	`94`	`+ @Override`
`110`	`95`	`public final Boolean getBooleanProperty(String key, Boolean defaultValue) {`
`111`	`96`	`return delegate.getBooleanProperty(key, defaultValue);`
`112`	`97`	`}`
`113`	`98`
	`99`	`+ @Override`
`114`	`100`	`public final Number getNumberProperty(String key) {`
`115`	`101`	`return delegate.getNumberProperty(key);`
`116`	`102`	`}`
`117`	`103`
	`104`	`+ @Override`
`118`	`105`	`public final Number getNumberProperty(String key, Number defaultValue) {`
`119`	`106`	`return delegate.getNumberProperty(key, defaultValue);`
`120`	`107`	`}`
`121`	`108`
	`109`	`+ @Override`
`122`	`110`	`public CompatVersion getCompatVersion() {`
`123`	`111`	`return compatVersion;`
`124`	`112`	`}`
`125`	`113`
	`114`	`+ @Override`
`126`	`115`	`public RackLogger getLogger() {`
`127`	`116`	`if (logger == null) {`
`128`	`117`	`logger = delegate.getLogger();`
`@@ -134,6 +123,7 @@ public void setLogger(RackLogger logger) {`
`134`	`123`	`this.logger = logger;`
`135`	`124`	`}`
`136`	`125`
	`126`	`+ @Override`
`137`	`127`	`public PrintStream getOut() {`
`138`	`128`	`return delegate.getOut();`
`139`	`129`	`}`
`@@ -142,6 +132,7 @@ public void setOut(OutputStream out) {`
`142`	`132`	`delegate.setOut(out);`
`143`	`133`	`}`
`144`	`134`
	`135`	`+ @Override`
`145`	`136`	`public PrintStream getErr() {`
`146`	`137`	`return delegate.getErr();`
`147`	`138`	`}`
`@@ -150,76 +141,93 @@ public void setErr(OutputStream err) {`
`150`	`141`	`delegate.setErr(err);`
`151`	`142`	`}`
`152`	`143`
	`144`	`+ @Override`
`153`	`145`	`public boolean isRewindable() {`
`154`	`146`	`return delegate.isRewindable();`
`155`	`147`	`}`
`156`	`148`
	`149`	`+ @Override`
`157`	`150`	`public Integer getInitialMemoryBufferSize() {`
`158`	`151`	`return delegate.getInitialMemoryBufferSize();`
`159`	`152`	`}`
`160`	`153`
	`154`	`+ @Override`
`161`	`155`	`public Integer getMaximumMemoryBufferSize() {`
`162`	`156`	`return delegate.getMaximumMemoryBufferSize();`
`163`	`157`	`}`
`164`	`158`
	`159`	`+ @Override`
`165`	`160`	`public String getRackup() {`
`166`	`161`	`return delegate.getRackup();`
`167`	`162`	`}`
`168`	`163`
	`164`	`+ @Override`
`169`	`165`	`public String getRackupPath() {`
`170`	`166`	`return delegate.getRackupPath();`
`171`	`167`	`}`
`172`	`168`
`173`	`169`	`// runtime pooling in embedded ENVs not implemented :`
`174`	`170`
	`171`	`+ @Override`
`175`	`172`	`public Integer getRuntimeTimeoutSeconds() {`
`176`	`173`	`throw new UnsupportedOperationException("getRuntimeTimeoutSeconds()");`
`177`	`174`	`}`
`178`	`175`
	`176`	`+ @Override`
`179`	`177`	`public Integer getInitialRuntimes() {`
`180`	`178`	`throw new UnsupportedOperationException("getInitialRuntimes()");`
`181`	`179`	`}`
`182`	`180`
	`181`	`+ @Override`
`183`	`182`	`public Integer getMaximumRuntimes() {`
`184`	`183`	`throw new UnsupportedOperationException("getMaximumRuntimes()");`
`185`	`184`	`}`
`186`	`185`
	`186`	`+ @Override`
`187`	`187`	`public String[] getRuntimeArguments() {`
`188`	`188`	`throw new UnsupportedOperationException("getRuntimeArguments()");`
`189`	`189`	`}`
`190`	`190`
	`191`	`+ @Override`
`191`	`192`	`public Integer getNumInitializerThreads() {`
`192`	`193`	`throw new UnsupportedOperationException("getNumInitializerThreads()");`
`193`	`194`	`}`
`194`	`195`
	`196`	`+ @Override`
`195`	`197`	`public boolean isSerialInitialization() {`
`196`	`198`	`throw new UnsupportedOperationException("isSerialInitialization()");`
`197`	`199`	`}`
`198`	`200`
	`201`	`+ @Override`
`199`	`202`	`public boolean isIgnoreEnvironment() {`
`200`	`203`	`throw new UnsupportedOperationException("isIgnoreEnvironment()");`
`201`	`204`	`}`
`202`	`205`
	`206`	`+ @Override`
`203`	`207`	`public Map<String, String> getRuntimeEnvironment() {`
`204`	`208`	`throw new UnsupportedOperationException("getRuntimeEnvironment()");`
`205`	`209`	`}`
`206`	`210`
`207`	`211`	`// RackFilter aint's used with embed :`
`208`	`212`
	`213`	`+ @Override`
`209`	`214`	`public boolean isFilterAddsHtml() {`
`210`	`215`	`throw new UnsupportedOperationException("isFilterAddsHtml()");`
`211`	`216`	`}`
`212`	`217`
	`218`	`+ @Override`
`213`	`219`	`public boolean isFilterVerifiesResource() {`
`214`	`220`	`throw new UnsupportedOperationException("isFilterVerifiesResource()");`
`215`	`221`	`}`
`216`	`222`
`217`	`223`	`// JMS configuration not used with embed :`
`218`	`224`
	`225`	`+ @Override`
`219`	`226`	`public String getJmsConnectionFactory() {`
`220`	`227`	`throw new UnsupportedOperationException("getJmsConnectionFactory()");`
`221`	`228`	`}`
`222`	`229`
	`230`	`+ @Override`
`223`	`231`	`public String getJmsJndiProperties() {`
`224`	`232`	`throw new UnsupportedOperationException("getJmsJndiProperties()");`
`225`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,7 @@`
`56`	`56`	`public class Logger extends RubyObject { // implements RackLogger`
`57`	`57`
`58`	`58`	`static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {`
	`59`	`+ @Override`
`59`	`60`	`public IRubyObject allocate(Ruby runtime, RubyClass klass) {`
`60`	`61`	`return new Logger(runtime, klass);`
`61`	`62`	`}`
`@@ -542,6 +543,7 @@ public IRubyObject stub(final ThreadContext context) {`
`542`	`543`	`public static class ServletLog extends RubyObject {`
`543`	`544`
`544`	`545`	`static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {`
	`546`	`+ @Override`
`545`	`547`	`public IRubyObject allocate(Ruby runtime, RubyClass klass) {`
`546`	`548`	`return new ServletLog(runtime, klass);`
`547`	`549`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@`
`42`	`42`	`public class Servlet extends RubyObject {`
`43`	`43`
`44`	`44`	`static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {`
	`45`	`+ @Override`
`45`	`46`	`public IRubyObject allocate(Ruby runtime, RubyClass klass) {`
`46`	`47`	`return new Servlet(runtime, klass);`
`47`	`48`	`}`