feat: Add a Resource trait for Webmachine resources

Author: rholshausen

Cargo.toml

@@ -12,6 +12,7 @@ edition = "2024"
 
 [dependencies]
 anyhow = "1.0.98"
+async-trait = "0.1.86"
 bytes = "1.10.1"
 chrono = "0.4.41"
 futures = "0.3.31"

src/content_negotiation.rs

@@ -1,11 +1,13 @@
 //! The `content_negotiation` module deals with handling media types, languages, charsets and
 //! encodings as per https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html.
 
-use itertools::Itertools;
 use std::cmp::Ordering;
-use crate::headers::HeaderValue;
+
+use itertools::Itertools;
+
+use crate::Resource;
 use crate::context::WebmachineRequest;
-use crate::WebmachineResource;
+use crate::headers::HeaderValue;
 
 /// Enum to represent a match with media types
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
@@ -116,22 +118,22 @@ pub fn sort_media_types(media_types: &Vec<HeaderValue>) -> Vec<HeaderValue> {
 
 /// Determines if the media types produced by the resource matches the acceptable media types
 /// provided by the client. Returns the match if there is one.
-pub fn matching_content_type(resource: &WebmachineResource, request: &WebmachineRequest) -> Option<String> {
+pub fn matching_content_type(resource: &(dyn Resource + Send + Sync), request: &WebmachineRequest) -> Option<String> {
   if request.has_accept_header() {
     let acceptable_media_types = sort_media_types(&request.accept());
-    resource.produces.iter()
-      .cloned()
+    resource.produces().iter()
       .cartesian_product(acceptable_media_types.iter())
       .map(|(produced, acceptable)| {
         let acceptable_media_type = acceptable.as_media_type();
-        let produced_media_type =  MediaType::parse_string(produced.as_str());
+        let produced_media_type =  MediaType::parse_string(produced);
         (produced_media_type.clone(), acceptable_media_type.clone(), produced_media_type.matches(&acceptable_media_type))
       })
       .sorted_by(|a, b| Ord::cmp(&a.2, &b.2))
       .filter(|val| val.2 != MediaTypeMatch::None)
-      .next().map(|result| result.0.to_string())
+      .next()
+      .map(|result| result.0.to_string())
   } else {
-    resource.produces.first().map(|s| s.to_string())
+    resource.produces().first().map(|s| s.to_string())
   }
 }
 
@@ -221,25 +223,25 @@ pub fn sort_media_languages(media_languages: &Vec<HeaderValue>) -> Vec<MediaLang
 
 /// Determines if the languages produced by the resource matches the acceptable languages
 /// provided by the client. Returns the match if there is one.
-pub fn matching_language(resource: &WebmachineResource, request: &WebmachineRequest) -> Option<String> {
+pub fn matching_language(resource: &(dyn Resource + Send + Sync), request: &WebmachineRequest) -> Option<String> {
   if request.has_accept_language_header() && !request.accept_language().is_empty() {
     let acceptable_languages = sort_media_languages(&request.accept_language());
-    if resource.languages_provided.is_empty() {
+    if resource.languages_provided().is_empty() {
       acceptable_languages.first().map(|lang| lang.to_string())
     } else {
       acceptable_languages.iter()
-        .cartesian_product(resource.languages_provided.iter())
+        .cartesian_product(resource.languages_provided().iter())
         .map(|(acceptable_language, produced_language)| {
           let produced_language = MediaLanguage::parse_string(produced_language);
           (produced_language.clone(), produced_language.matches(&acceptable_language))
         })
         .find(|val| val.1)
         .map(|result| result.0.to_string())
     }
-  } else if resource.languages_provided.is_empty() {
+  } else if resource.languages_provided().is_empty() {
     Some("*".to_string())
   } else {
-    resource.languages_provided.first().map(|s| s.to_string())
+    resource.languages_provided().first().map(|s| s.to_string())
   }
 }
 
@@ -311,25 +313,25 @@ pub fn sort_media_charsets(charsets: &Vec<HeaderValue>) -> Vec<Charset> {
 
 /// Determines if the charsets produced by the resource matches the acceptable charsets
 /// provided by the client. Returns the match if there is one.
-pub fn matching_charset(resource: &WebmachineResource, request: &WebmachineRequest) -> Option<String> {
+pub fn matching_charset(resource: &(dyn Resource + Send + Sync), request: &WebmachineRequest) -> Option<String> {
   if request.has_accept_charset_header() && !request.accept_charset().is_empty() {
     let acceptable_charsets = sort_media_charsets(&request.accept_charset());
-    if resource.charsets_provided.is_empty() {
+    if resource.charsets_provided().is_empty() {
       acceptable_charsets.first().map(|cs| cs.to_string())
     } else {
       acceptable_charsets.iter()
-        .cartesian_product(resource.charsets_provided.iter())
+        .cartesian_product(resource.charsets_provided().iter())
         .map(|(acceptable_charset, provided_charset)| {
             let provided_charset = Charset::parse_string(provided_charset);
             (provided_charset.clone(), provided_charset.matches(&acceptable_charset))
         })
         .find(|val| val.1)
         .map(|result| result.0.to_string())
     }
-  } else if resource.charsets_provided.is_empty() {
+  } else if resource.charsets_provided().is_empty() {
     Some("ISO-8859-1".to_string())
   } else {
-    resource.charsets_provided.first().map(|s| s.to_string())
+    resource.charsets_provided().first().map(|s| s.to_string())
   }
 }
 
@@ -401,29 +403,29 @@ pub fn sort_encodings(encodings: &Vec<HeaderValue>) -> Vec<Encoding> {
 
 /// Determines if the encodings supported by the resource matches the acceptable encodings
 /// provided by the client. Returns the match if there is one.
-pub fn matching_encoding(resource: &WebmachineResource, request: &WebmachineRequest) -> Option<String> {
+pub fn matching_encoding(resource: &(dyn Resource + Send + Sync), request: &WebmachineRequest) -> Option<String> {
   let identity = Encoding::parse_string("identity");
   if request.has_accept_encoding_header() {
     let acceptable_encodings = sort_encodings(&request.accept_encoding());
-    if resource.encodings_provided.is_empty() {
+    if resource.encodings_provided().is_empty() {
       if acceptable_encodings.contains(&identity) {
         Some("identity".to_string())
       } else {
         None
       }
     } else {
       acceptable_encodings.iter()
-        .cartesian_product(resource.encodings_provided.iter())
+        .cartesian_product(resource.encodings_provided().iter())
         .map(|(acceptable_encoding, provided_encoding)| {
           let provided_encoding = Encoding::parse_string(provided_encoding);
           (provided_encoding.clone(), provided_encoding.matches(&acceptable_encoding))
         })
         .find(|val| val.1)
         .map(|result| { result.0.to_string() })
     }
-  } else if resource.encodings_provided.is_empty() {
+  } else if resource.encodings_provided().is_empty() {
     Some("identity".to_string())
   } else {
-    resource.encodings_provided.first().map(|s| s.to_string())
+    resource.encodings_provided().first().map(|s| s.to_string())
   }
 }

src/context.rs

@@ -197,18 +197,18 @@ impl WebmachineResponse {
     }
 
     /// Adds standard CORS headers to the response
-    pub fn add_cors_headers(&mut self, allowed_methods: &Vec<String>) {
+    pub fn add_cors_headers(&mut self, allowed_methods: &[&str]) {
       let cors_headers = WebmachineResponse::cors_headers(allowed_methods);
       for (k, v) in cors_headers {
         self.add_header(k.as_str(), v.iter().map(HeaderValue::basic).collect());
       }
     }
 
     /// Returns a HashMap of standard CORS headers
-    pub fn cors_headers(allowed_methods: &Vec<String>) -> HashMap<String, Vec<String>> {
+    pub fn cors_headers(allowed_methods: &[&str]) -> HashMap<String, Vec<String>> {
       hashmap!{
         "Access-Control-Allow-Origin".to_string() => vec!["*".to_string()],
-        "Access-Control-Allow-Methods".to_string() => allowed_methods.clone(),
+        "Access-Control-Allow-Methods".to_string() => allowed_methods.iter().map(|v| v.to_string()).collect(),
         "Access-Control-Allow-Headers".to_string() => vec!["Content-Type".to_string()]
       }
     }

src/headers.rs

@@ -211,6 +211,13 @@ impl PartialEq<HeaderValue> for HeaderValue {
     }
 }
 
+impl PartialEq<&HeaderValue> for HeaderValue {
+  fn eq(&self, other: &&HeaderValue) -> bool {
+    self == *other
+  }
+}
+
+
 impl PartialEq<String> for HeaderValue {
     fn eq(&self, other: &String) -> bool {
         self.value == *other