Add support for getting query_params from requests.

Author: alistairjevans

Cargo.lock

@@ -25,3 +25,4 @@ h2 = "0.4"
 async-stream = "0.3.5"
 env_logger = "0.11"
 log = "0.4"
+form_urlencoded = "1.2.1"

ext/hyper_ruby/Cargo.toml

@@ -593,6 +593,8 @@ fn init(ruby: &Ruby) -> Result<(), MagnusError> {
     let request_class = module.define_class("Request", ruby.class_object())?;
     request_class.define_method("http_method", method!(Request::method, 0))?;
     request_class.define_method("path", method!(Request::path, 0))?;
+    request_class.define_method("query_params", method!(Request::query_params, 0))?;
+    request_class.define_method("query_param", method!(Request::query_param, 1))?;
     request_class.define_method("header", method!(Request::header, 1))?;
     request_class.define_method("headers", method!(Request::headers, 0))?;
     request_class.define_method("body", method!(Request::body, 0))?;

ext/hyper_ruby/src/lib.rs

@@ -9,6 +9,7 @@ use rb_sys::{rb_str_set_len, rb_str_modify, rb_str_modify_expand, rb_str_capacit
 
 use crate::grpc;
 use log::debug;
+use form_urlencoded;
 
 // Trait for common buffer filling behavior
 trait FillBuffer {
@@ -104,6 +105,28 @@ impl Request {
         RString::new(self.request.uri().path())
     }
 
+    pub fn query_params(&self) -> RHash {
+        let params = RHash::new();
+        if let Some(query) = self.request.uri().query() {
+            for (key, value) in form_urlencoded::parse(query.as_bytes()) {
+                params.aset(key.to_string(), value.to_string()).unwrap();
+            }
+        }
+        params
+    }
+
+    pub fn query_param(&self, key: RString) -> Value {
+        let key_str = unsafe { key.as_str().unwrap() };
+        if let Some(query) = self.request.uri().query() {
+            for (param_key, value) in form_urlencoded::parse(query.as_bytes()) {
+                if param_key == key_str {
+                    return RString::new(&value).as_value();
+                }
+            }
+        }
+        qnil().as_value()
+    }
+
     pub fn header(&self, key: RString) -> Value {
         let key_str = unsafe { key.as_str().unwrap() };
         match self.request.headers().get(key_str) {
@@ -142,8 +165,11 @@ impl Request {
     pub fn inspect(&self) -> RString {
         let method = self.request.method().to_string();
         let path = self.request.uri().path();
+        let query = self.request.uri().query().unwrap_or("");
+        let query_display = if !query.is_empty() { format!("?{}", query) } else { String::new() };
         let body_size = self.body_size();
-        RString::new(&format!("#<HyperRuby::Request method={} path={} body_size={}>", method, path, body_size))
+        RString::new(&format!("#<HyperRuby::Request method={} path={}{} body_size={}>", 
+            method, path, query_display, body_size))
     }
 }
 

ext/hyper_ruby/src/request.rs

@@ -215,6 +215,32 @@ def test_unix_socket_directory_error
     end
   end
 
+  def test_query_params
+    with_server(-> (request) { handler_query_params(request) }) do |client|
+      response = client.get("/?name=John&age=30&verified")
+      assert_equal 200, response.status
+      
+      data = JSON.parse(response.body)
+      assert_equal "John", data["query_params"]["name"]
+      assert_equal "30", data["query_params"]["age"]
+      assert_equal "", data["query_params"]["verified"]
+      
+      assert_equal "John", data["query_param_name"]
+      assert_nil data["query_param_missing"]
+    end
+  end
+  
+  def test_query_params_with_encoding
+    with_server(-> (request) { handler_query_params(request) }) do |client|
+      response = client.get("/?q=hello%20world&filter=type%3Duser")
+      assert_equal 200, response.status
+      
+      data = JSON.parse(response.body)
+      assert_equal "hello world", data["query_params"]["q"]
+      assert_equal "type=user", data["query_params"]["filter"]
+    end
+  end
+
   private
 
   def handler_simple(request)
@@ -242,4 +268,18 @@ def handler_accept(request, buffer)
     request.fill_body(buffer)
     ACCEPT_RESPONSE
   end
+
+  def handler_query_params(request)
+    response_data = {
+      query_params: request.query_params,
+      query_param_name: request.query_param("name"),
+      query_param_missing: request.query_param("missing")
+    }
+    
+    HyperRuby::Response.new(
+      200,
+      { 'Content-Type' => 'application/json' },
+      JSON.generate(response_data)
+    )
+  end
 end