From 621a79a33495a89aed6f37cb655ba58f95b1ed43 Mon Sep 17 00:00:00 2001
From: Leynos <leynos@troubledskies.net>
Date: Fri, 13 Jun 2025 22:57:27 +0100
Subject: [PATCH] Expand middleware and extractor tasks

---
 docs/roadmap.md   | 11 +++++++++++
 src/extractor.rs  | 37 ++-----------------------------------
 src/middleware.rs |  2 +-
 src/server.rs     | 10 ++++++----
 4 files changed, 20 insertions(+), 40 deletions(-)

diff --git a/docs/roadmap.md b/docs/roadmap.md
index 811ef135..177459ab 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -59,6 +59,17 @@ after formatting. Line numbers below refer to that file.
 
 - [ ] Develop a minimal middleware system and extractor traits for payloads,
   connection metadata, and shared state.
+  - [ ] Define `FromMessageRequest` for extractor types (lines 760-782).
+  - [ ] Provide built-in extractors `Message<T>`, `ConnectionInfo`, and
+        `SharedState<T>` (lines 792-840).
+  - [ ] Support custom extractors implementing `FromMessageRequest`
+        (lines 842-858).
+  - [ ] Implement middleware using `Transform`/`Service` traits and a simple
+        `from_fn` style variant (lines 866-899).
+  - [ ] Register middleware with `WireframeApp::wrap` and execute it in order
+        (lines 900-919).
+  - [ ] Document common middleware use cases like logging and authentication
+        (lines 920-935).
 
 ## 3. Initial Examples and Documentation
 
diff --git a/src/extractor.rs b/src/extractor.rs
index d77d23bf..6d86b839 100644
--- a/src/extractor.rs
+++ b/src/extractor.rs
@@ -76,6 +76,7 @@ impl<T: Send + Sync> SharedState<T> {
     /// ```
     /// use std::sync::Arc;
     /// use wireframe::extractor::SharedState;
+    ///
     /// let state = Arc::new(42);
     /// let shared = SharedState::new(state.clone());
     /// assert_eq!(*shared, 42);
@@ -97,28 +98,6 @@ impl<T: Send + Sync> From<T> for SharedState<T> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn advance_consumes_bytes() {
-        let mut payload = Payload { data: b"hello" };
-        payload.advance(2);
-        assert_eq!(payload.data, b"llo");
-        payload.advance(10);
-        assert!(payload.data.is_empty());
-    }
-
-    #[test]
-    fn remaining_reports_length() {
-        let mut payload = Payload { data: b"abc" };
-        assert_eq!(payload.remaining(), 3);
-        payload.advance(1);
-        assert_eq!(payload.remaining(), 2);
-    }
-}
-
 impl<T: Send + Sync> std::ops::Deref for SharedState<T> {
     type Target = T;
 
@@ -131,21 +110,9 @@ impl<T: Send + Sync> std::ops::Deref for SharedState<T> {
     /// ```
     /// use std::sync::Arc;
     /// use wireframe::extractor::SharedState;
-    /// let state = Arc::new(42);
-    /// let shared = SharedState::new(state.clone());
-    /// assert_eq!(*shared, 42);
-    /// Returns a reference to the inner shared state value.
-    ///
-    /// Allows transparent access to the wrapped state as if it were a reference to the underlying type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::Arc;
-    /// use wireframe::extractor::SharedState;
     ///
     /// let state = Arc::new(42);
-    /// let shared = SharedState::new(state);
+    /// let shared = SharedState::new(state.clone());
     /// assert_eq!(*shared, 42);
     /// ```
     fn deref(&self) -> &Self::Target {
diff --git a/src/middleware.rs b/src/middleware.rs
index a9e93eab..671735ac 100644
--- a/src/middleware.rs
+++ b/src/middleware.rs
@@ -27,7 +27,7 @@ where
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```ignore
     /// # use your_crate::{Next, Service, ServiceRequest};
     /// # struct MyService;
     /// # impl Service for MyService {
diff --git a/src/server.rs b/src/server.rs
index b29679c7..46054781 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -36,11 +36,13 @@ where
     /// If the CPU count cannot be determined, the server defaults to a single
     /// worker.
     ///
-    /// ```no_run
+    /// ```ignore
     /// use wireframe::{app::WireframeApp, server::WireframeServer};
     ///
     /// let factory = || WireframeApp::new().unwrap();
     /// let server = WireframeServer::new(factory);
+    /// ```
+    ///
     /// Creates a new `WireframeServer` with the provided factory closure.
     ///
     /// The server is initialised with a default worker count equal to the number of available CPU cores, or 1 if this cannot be determined. The TCP listener is unset and must be configured with `bind` before running the server.
@@ -51,7 +53,7 @@ where
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```ignore
     /// let server = WireframeServer::new(|| WireframeApp::default());
     /// assert!(server.worker_count() >= 1);
     /// ```
@@ -81,7 +83,7 @@ where
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```ignore
     /// let server = WireframeServer::new(factory).workers(4);
     /// assert_eq!(server.worker_count(), 4);
     /// let server = server.workers(0);
@@ -99,7 +101,7 @@ where
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```ignore
     /// let server = WireframeServer::new(factory);
     /// assert!(server.worker_count() >= 1);
     /// ```