implement separated handler for request

src/app/browser/window/tab/item/page/client.rs

@@ -73,7 +73,9 @@ impl Client {
             time: now(),
             value: query.to_string(),
         });
-        Request::route(self, query, None, self.new_cancellable(), callback);
+        Request::parse(query, None)
+            .unwrap() // @TODO
+            .handle(self, self.new_cancellable(), callback);
     }
 
     /// Get new [Cancellable](https://docs.gtk.org/gio/class.Cancellable.html) by cancel previous one

src/app/browser/window/tab/item/page/client/request.rs

@@ -1,7 +1,9 @@
+mod error;
 mod feature;
 mod gemini;
 
 use super::{Client, Response};
+use error::Error;
 use feature::Feature;
 use gtk::{
     gio::Cancellable,
@@ -19,27 +21,49 @@ pub enum Request {
 }
 
 impl Request {
-    // Actions
+    // Constructors
 
-    /// Process request by routed driver
-    pub fn route(
-        client: &Client,
-        query: &str,
-        referrer: Option<Vec<Self>>,
-        cancellable: Cancellable,
-        callback: impl FnOnce(Response) + 'static,
-    ) {
+    /// Create new `Self` from string
+    pub fn parse(query: &str, referrer: Option<Vec<Self>>) -> Result<Self, Error> {
         let (feature, request) = Feature::parse(query);
 
         match Uri::parse(request, UriFlags::NONE) {
             Ok(uri) => match uri.scheme().as_str() {
-                "gemini" => gemini::route(client, feature, uri, referrer, cancellable, callback),
-                "titan" => todo!(),
-                _ => callback(Response::Redirect(
-                    todo!(), //super::response::Redirect::Foreground(()),
-                )),
+                "gemini" => Ok(Self::Gemini {
+                    feature,
+                    referrer: referrer.unwrap_or_default(),
+                    uri,
+                }),
+                "titan" => Ok(Self::Titan(uri)),
+                _ => Err(Error::Unsupported),
             },
-            Err(_) => todo!(),
+            Err(e) => Err(Error::Glib(e)),
+        }
+    }
+
+    // Actions
+
+    /// Handle `Self` request
+    pub fn handle(
+        self,
+        client: &Client,
+        cancellable: Cancellable,
+        callback: impl FnOnce(Response) + 'static,
+    ) {
+        match self {
+            Self::Gemini {
+                feature,
+                referrer,
+                uri,
+            } => gemini::route(
+                client,
+                feature.clone(),
+                uri.clone(),
+                referrer,
+                cancellable,
+                callback,
+            ),
+            Self::Titan(_) => todo!(),
         }
     }
 

src/app/browser/window/tab/item/page/client/request/error.rs

@@ -0,0 +1,16 @@
+use std::fmt::{Display, Formatter, Result};
+
+#[derive(Debug)]
+pub enum Error {
+    Glib(gtk::glib::Error),
+    Unsupported,
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        match self {
+            Self::Glib(e) => write!(f, "{e}"),
+            Self::Unsupported => write!(f, "Request not supported"),
+        }
+    }
+}

src/app/browser/window/tab/item/page/client/request/gemini.rs

@@ -9,7 +9,7 @@ pub fn route(
     client: &Client,
     feature: Feature,
     uri: Uri,
-    referrer: Option<Vec<Request>>,
+    referrer: Vec<Request>,
     cancellable: Cancellable,
     callback: impl FnOnce(Response) + 'static,
 ) {
@@ -57,7 +57,7 @@ fn handle(
     response: ggemini::client::connection::Response,
     base: Uri,
     cancellable: Cancellable,
-    referrer: Option<Vec<Request>>,
+    referrer: Vec<Request>,
     feature: Feature,
     callback: impl FnOnce(Response) + 'static,
 ) {
@@ -123,7 +123,7 @@ fn handle(
         Status::Redirect => callback(redirect(
             response.meta.data,
             base,
-            referrer.unwrap_or_default(), // @TODO
+            referrer,
             cancellable,
             Priority::DEFAULT,
             false,
@@ -132,7 +132,7 @@ fn handle(
         Status::PermanentRedirect => callback(redirect(
             response.meta.data,
             base,
-            referrer.unwrap_or_default(), // @TODO
+            referrer,
             cancellable,
             Priority::DEFAULT,
             true,