mirrors/actix-web
1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-06-12 02:09:36 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into improve-typed-header-macro

Browse source
This commit is contained in:
Rob Ede 2021-12-02 14:04:23 +00:00 committed by GitHub
parent a75212695a 075d871e63
commit 57ee49a618
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
20 changed files with 226 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
actix-http/src/h1/decoder.rs
View file

@ -174,7 +174,7 @@ pub(crate) trait MessageType: Sized {
self.set_expect()
}
// https://tools.ietf.org/html/rfc7230#section-3.3.3
// https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.3
if chunked {
// Chunked encoding
Ok(PayloadLength::Payload(PayloadType::Payload(

7
actix-http/src/h1/encoder.rs
View file

@ -71,15 +71,16 @@ pub(crate) trait MessageType: Sized {
| StatusCode::PROCESSING
| StatusCode::NO_CONTENT => {
// skip content-length and transfer-encoding headers
// see https://tools.ietf.org/html/rfc7230#section-3.3.1
// and https://tools.ietf.org/html/rfc7230#section-3.3.2
// see https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.1
// and https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2
skip_len = true;
length = BodySize::None
}
StatusCode::NOT_MODIFIED => {
// 304 responses should never have a body but should retain a manually set
// content-length header see https://tools.ietf.org/html/rfc7232#section-4.1
// content-length header
// see https://datatracker.ietf.org/doc/html/rfc7232#section-4.1
skip_len = false;
length = BodySize::None;
}

2
actix-http/src/h2/dispatcher.rs
View file

@ -304,7 +304,7 @@ fn prepare_response(
for (key, value) in head.headers.iter() {
match *key {
// TODO: consider skipping other headers according to:
// https://tools.ietf.org/html/rfc7540#section-8.1.2.2
// https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2.2
// omit HTTP/1.x only headers
CONNECTION | TRANSFER_ENCODING => continue,
CONTENT_LENGTH if skip_len => continue,

4
actix-http/src/header/mod.rs
View file

@ -55,7 +55,7 @@ pub trait Header: IntoHeaderValue {
fn name() -> HeaderName;
/// Parse a header
fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
fn parse<M: HttpMessage>(msg: &M) -> Result<Self, ParseError>;
}
/// Convert `http::HeaderMap` to our `HeaderMap`.
@ -66,7 +66,7 @@ impl From<http::HeaderMap> for HeaderMap {
}
/// This encode set is used for HTTP header values and is defined at
/// <https://tools.ietf.org/html/rfc5987#section-3.2>.
/// <https://datatracker.ietf.org/doc/html/rfc5987#section-3.2>.
pub(crate) const HTTP_VALUE: &AsciiSet = &CONTROLS
.add(b' ')
.add(b'"')

6
actix-http/src/header/shared/extended.rs
View file

@ -1,17 +1,17 @@
// Originally from hyper v0.11.27 src/header/parsing.rs
use std::{fmt, str::FromStr};
use language_tags::LanguageTag;
use crate::header::{Charset, HTTP_VALUE};
// From hyper v0.11.27 src/header/parsing.rs
/// The value part of an extended parameter consisting of three parts:
/// - The REQUIRED character set name (`charset`).
/// - The OPTIONAL language information (`language_tag`).
/// - A character sequence representing the actual value (`value`), separated by single quotes.
///
/// It is defined in [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
/// It is defined in [RFC 5987 §3.2](https://datatracker.ietf.org/doc/html/rfc5987#section-3.2).
#[derive(Clone, Debug, PartialEq)]
pub struct ExtendedValue {
/// The character set that is used to encode the `value` to a string.

9
actix-http/src/header/shared/quality_item.rs
View file

@ -25,8 +25,8 @@ const MAX_FLOAT_QUALITY: f32 = 1.0;
/// a value between 0 and 1000 e.g. `Quality(532)` matches the quality
/// `q=0.532`.
///
/// [RFC7231 Section 5.3.1](https://tools.ietf.org/html/rfc7231#section-5.3.1)
/// gives more information on quality values in HTTP header fields.
/// [RFC 7231 §5.3.1](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.1) gives more
/// information on quality values in HTTP header fields.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct Quality(u16);
@ -78,8 +78,9 @@ impl TryFrom<f32> for Quality {
}
}
/// Represents an item with a quality value as defined in
/// [RFC 7231](https://tools.ietf.org/html/rfc7231#section-5.3.1).
/// Represents an item with a quality value as defined
/// in [RFC 7231 §5.3.1](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.1).
#[derive(Clone, PartialEq, Debug)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QualityItem<T> {
/// The wrapped contents of the field.

33
actix-http/src/header/utils.rs
View file

@ -12,7 +12,8 @@ where
I: Iterator<Item = &'a HeaderValue> + 'a,
T: FromStr,
{
let mut result = Vec::new();
let size_guess = all.size_hint().1.unwrap_or(2);
let mut result = Vec::with_capacity(size_guess);
for h in all {
let s = h.to_str().map_err(|_| ParseError::Header)?;
@ -26,6 +27,7 @@ where
.filter_map(|x| x.trim().parse().ok()),
)
}
Ok(result)
}
@ -34,10 +36,12 @@ where
pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>) -> Result<T, ParseError> {
if let Some(line) = val {
let line = line.to_str().map_err(|_| ParseError::Header)?;
if !line.is_empty() {
return T::from_str(line).or(Err(ParseError::Header));
}
}
Err(ParseError::Header)
}
@ -48,20 +52,45 @@ where
T: fmt::Display,
{
let mut iter = parts.iter();
if let Some(part) = iter.next() {
fmt::Display::fmt(part, f)?;
}
for part in iter {
f.write_str(", ")?;
fmt::Display::fmt(part, f)?;
}
Ok(())
}
/// Percent encode a sequence of bytes with a character set defined in
/// <https://tools.ietf.org/html/rfc5987#section-3.2>
/// <https://datatracker.ietf.org/doc/html/rfc5987#section-3.2>
#[inline]
pub fn http_percent_encode(f: &mut fmt::Formatter<'_>, bytes: &[u8]) -> fmt::Result {
let encoded = percent_encoding::percent_encode(bytes, HTTP_VALUE);
fmt::Display::fmt(&encoded, f)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn comma_delimited_parsing() {
let headers = vec![];
let res: Vec<usize> = from_comma_delimited(headers.iter()).unwrap();
assert_eq!(res, vec![0; 0]);
let headers = vec![
HeaderValue::from_static(""),
HeaderValue::from_static(","),
HeaderValue::from_static(" "),
HeaderValue::from_static("1 ,"),
HeaderValue::from_static(""),
];
let res: Vec<usize> = from_comma_delimited(headers.iter()).unwrap();
assert_eq!(res, vec![1]);
}
}

3
actix-http/src/ws/proto.rs
View file

@ -222,7 +222,8 @@ impl<T: Into<String>> From<(CloseCode, T)> for CloseReason {
}
}
/// The WebSocket GUID as stated in the spec. See <https://tools.ietf.org/html/rfc6455#section-1.3>.
/// The WebSocket GUID as stated in the spec.
/// See <https://datatracker.ietf.org/doc/html/rfc6455#section-1.3>.
static WS_GUID: &[u8] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
/// Hashes the `Sec-WebSocket-Key` header according to the WebSocket spec.

2
actix-multipart/src/error.rs
View file

@ -10,7 +10,7 @@ use derive_more::{Display, Error, From};
pub enum MultipartError {
/// Content-Disposition header is not found or is not equal to "form-data".
///
/// According to [RFC 7578](https://tools.ietf.org/html/rfc7578#section-4.2) a
/// According to [RFC 7578 §4.2](https://datatracker.ietf.org/doc/html/rfc7578#section-4.2) a
/// Content-Disposition header must always be present and equal to "form-data".
#[display(fmt = "No Content-Disposition `form-data` header")]
NoContentDisposition,

4
actix-multipart/src/server.rs
View file

@ -337,8 +337,8 @@ impl InnerMultipart {
return Poll::Pending;
};
// According to [RFC 7578](https://tools.ietf.org/html/rfc7578#section-4.2) a
// Content-Disposition header must always be present and set to "form-data".
// According to RFC 7578 §4.2, a Content-Disposition header must always be present and
// set to "form-data".
let content_disposition = headers
.get(&header::CONTENT_DISPOSITION)

3
awc/src/client/h1proto.rs
View file

@ -66,8 +66,7 @@ where
let mut framed = Framed::new(io, h1::ClientCodec::default());
// Check EXPECT header and enable expect handle flag accordingly.
//
// RFC: https://tools.ietf.org/html/rfc7231#section-5.1.1
// See https://datatracker.ietf.org/doc/html/rfc7231#section-5.1.1
let is_expect = if head.as_ref().headers.contains_key(EXPECT) {
match body.size() {
BodySize::None | BodySize::Sized(0) => {

2
awc/src/client/h2proto.rs
View file

@ -90,7 +90,7 @@ where
for (key, value) in headers {
match *key {
// TODO: consider skipping other headers according to:
// https://tools.ietf.org/html/rfc7540#section-8.1.2.2
// https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2.2
// omit HTTP/1.x only headers
CONNECTION | TRANSFER_ENCODING => continue,
CONTENT_LENGTH if skip_len => continue,

35
src/http/header/accept.rs
View file

@ -77,7 +77,7 @@ crate::http::header::common_header! {
/// ])
/// );
/// ```
(Accept, header::ACCEPT) => (QualityItem<Mime>)+
(Accept, header::ACCEPT) => (QualityItem<Mime>)*
test_parse_and_format {
// Tests from the RFC
@ -155,7 +155,7 @@ impl Accept {
/// Returns a sorted list of mime types from highest to lowest preference, accounting for
/// [q-factor weighting] and specificity.
///
/// [q-factor weighting]: https://tools.ietf.org/html/rfc7231#section-5.3.2
/// [q-factor weighting]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
pub fn ranked(&self) -> Vec<Mime> {
if self.is_empty() {
return vec![];
@ -207,12 +207,29 @@ impl Accept {
/// If no q-factors are provided, the first mime type is chosen. Note that items without
/// q-factors are given the maximum preference value.
///
/// Returns `None` if contained list is empty.
/// As per the spec, will return [`Mime::STAR_STAR`] (indicating no preference) if the contained
/// list is empty.
///
/// [q-factor weighting]: https://tools.ietf.org/html/rfc7231#section-5.3.2
pub fn preference(&self) -> Option<Mime> {
// PERF: creating a sorted list is not necessary
self.ranked().into_iter().next()
/// [q-factor weighting]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
pub fn preference(&self) -> Mime {
use actix_http::header::q;
let mut max_item = None;
let mut max_pref = q(0);
// uses manual max lookup loop since we want the first occurrence in the case of same
// preference but `Iterator::max_by_key` would give us the last occurrence
for pref in &self.0 {
// only change if strictly greater
// equal items, even while unsorted, still have higher preference if they appear first
if pref.quality > max_pref {
max_pref = pref.quality;
max_item = Some(pref.item.clone());
}
}
max_item.unwrap_or(mime::STAR_STAR)
}
}
@ -264,7 +281,7 @@ mod tests {
QualityItem::new("application/xml".parse().unwrap(), q(0.9)),
QualityItem::new(mime::STAR_STAR, q(0.8)),
]);
assert_eq!(test.preference(), Some(mime::TEXT_HTML));
assert_eq!(test.preference(), mime::TEXT_HTML);
let test = Accept(vec![
QualityItem::new("video/*".parse().unwrap(), q(0.8)),
@ -273,6 +290,6 @@ mod tests {
qitem(mime::IMAGE_SVG),
QualityItem::new(mime::IMAGE_STAR, q(0.8)),
]);
assert_eq!(test.preference(), Some(mime::IMAGE_PNG));
assert_eq!(test.preference(), mime::IMAGE_PNG);
}
}

61
src/http/header/accept_language.rs
View file

@ -1,9 +1,12 @@
use language_tags::LanguageTag;
use super::{common_header, AnyOrSome, QualityItem};
use super::{common_header, Preference, QualityItem};
use crate::http::header;
common_header! {
/// `Accept-Language` header, defined
/// in [RFC 7231 §5.3.5](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.5)
///
/// The `Accept-Language` header field can be used by user agents to indicate the set of natural
/// languages that are preferred in the response.
///
@ -29,32 +32,36 @@ common_header! {
/// # Examples
/// ```
/// use actix_web::HttpResponse;
/// use actix_web::http::header::{AcceptLanguage, LanguageTag, qitem};
/// use actix_web::http::header::{AcceptLanguage, qitem};
///
/// let mut builder = HttpResponse::Ok();
/// builder.insert_header(
/// AcceptLanguage(vec![
/// qitem(LanguageTag::parse("en-US").unwrap())
/// qitem("en-US".parse().unwrap())
/// ])
/// );
/// ```
///
/// ```
/// use actix_web::HttpResponse;
/// use actix_web::http::header::{AcceptLanguage, LanguageTag, QualityItem, q, qitem};
/// use actix_web::http::header::{AcceptLanguage, QualityItem, q, qitem};
///
/// let mut builder = HttpResponse::Ok();
/// builder.insert_header(
/// AcceptLanguage(vec![
/// qitem(LanguageTag::parse("da").unwrap()),
/// QualityItem::new(LanguageTag::parse("en-GB").unwrap(), q(800)),
/// QualityItem::new(LanguageTag::parse("en").unwrap(), q(700)),
/// qitem("da".parse().unwrap()),
/// QualityItem::new("en-GB".parse().unwrap(), q(800)),
/// QualityItem::new("en".parse().unwrap(), q(700)),
/// ])
/// );
/// ```
(AcceptLanguage, header::ACCEPT_LANGUAGE) => (QualityItem<AnyOrSome<LanguageTag>>)+
(AcceptLanguage, header::ACCEPT_LANGUAGE) => (QualityItem<Preference<LanguageTag>>)*
test_parse_and_format {
common_header_test!(no_headers, vec![b""; 0], Some(AcceptLanguage(vec![])));
common_header_test!(empty_header, vec![b""; 1], Some(AcceptLanguage(vec![])));
common_header_test!(
example_from_rfc,
vec![b"da, en-gb;q=0.8, en;q=0.7"]
@ -89,7 +96,7 @@ impl AcceptLanguage {
/// for [q-factor weighting].
///
/// [q-factor weighting]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
pub fn ranked(&self) -> Vec<AnyOrSome<LanguageTag>> {
pub fn ranked(&self) -> Vec<Preference<LanguageTag>> {
if self.0.is_empty() {
return vec![];
}
@ -110,12 +117,28 @@ impl AcceptLanguage {
/// If no q-factors are provided, the first language is chosen. Note that items without
/// q-factors are given the maximum preference value.
///
/// As per the spec, returns [`AnyOrSome::Any`] if contained list is empty.
/// As per the spec, returns [`Preference::Any`] if contained list is empty.
///
/// [q-factor weighting]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
pub fn preference(&self) -> AnyOrSome<LanguageTag> {
// PERF: creating a sorted list is not necessary
self.ranked().into_iter().next().unwrap_or(AnyOrSome::Any)
pub fn preference(&self) -> Preference<LanguageTag> {
use actix_http::header::q;
let mut max_item = None;
let mut max_pref = q(0);
// uses manual max lookup loop since we want the first occurrence in the case of same
// preference but `Iterator::max_by_key` would give us the last occurrence
for pref in &self.0 {
// only change if strictly greater
// equal items, even while unsorted, still have higher preference if they appear first
if pref.quality > max_pref {
max_pref = pref.quality;
max_item = Some(pref.item.clone());
}
}
max_item.unwrap_or(Preference::Any)
}
}
@ -178,7 +201,10 @@ mod tests {
QualityItem::new("*".parse().unwrap(), q(500)),
QualityItem::new("de".parse().unwrap(), q(700)),
]);
assert_eq!(test.preference(), AnyOrSome::Item("fr-CH".parse().unwrap()));
assert_eq!(
test.preference(),
Preference::Specific("fr-CH".parse().unwrap())
);
let test = AcceptLanguage(vec![
qitem("fr".parse().unwrap()),
@ -187,9 +213,12 @@ mod tests {
qitem("*".parse().unwrap()),
qitem("de".parse().unwrap()),
]);
assert_eq!(test.preference(), AnyOrSome::Item("fr".parse().unwrap()));
assert_eq!(
test.preference(),
Preference::Specific("fr".parse().unwrap())
);
let test = AcceptLanguage(vec![]);
assert_eq!(test.preference(), AnyOrSome::Any);
assert_eq!(test.preference(), Preference::Any);
}
}

9
src/http/header/content_disposition.rs
View file

@ -204,9 +204,9 @@ impl DispositionParam {
/// A *Content-Disposition* header. It is compatible to be used either as
/// [a response header for the main body](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#as_a_response_header_for_the_main_body)
/// as (re)defined in [RFC 6266](https://tools.ietf.org/html/rfc6266), or as
/// as (re)defined in [RFC 6266](https://datatracker.ietf.org/doc/html/rfc6266), or as
/// [a header for a multipart body](https://mdn.io/Content-Disposition#As_a_header_for_a_multipart_body)
/// as (re)defined in [RFC 7587](https://tools.ietf.org/html/rfc7578).
/// as (re)defined in [RFC 7587](https://datatracker.ietf.org/doc/html/rfc7578).
///
/// In a regular HTTP response, the *Content-Disposition* response header is a header indicating if
/// the content is expected to be displayed *inline* in the browser, that is, as a Web page or as
@ -299,8 +299,9 @@ impl DispositionParam {
/// # Security Note
/// If "filename" parameter is supplied, do not use the file name blindly, check and possibly
/// change to match local file system conventions if applicable, and do not use directory path
/// information that may be present. See [RFC 2183](https://tools.ietf.org/html/rfc2183#section-2.3).
// TODO: private fields and use smallvec
/// information that may be present.
/// See [RFC 2183 §2.3](https://datatracker.ietf.org/doc/html/rfc2183#section-2.3).
// TODO: think about using private fields and smallvec
#[derive(Clone, Debug, PartialEq)]
pub struct ContentDisposition {
/// The disposition type

3
src/http/header/content_range.rs
View file

@ -71,7 +71,8 @@ crate::http::header::common_header! {
}
}
/// Content-Range, described in [RFC 7233](https://tools.ietf.org/html/rfc7233#section-4.2)
/// Content-Range header, defined
/// in [RFC 7233 §4.2](https://datatracker.ietf.org/doc/html/rfc7233#section-4.2)
///
/// # ABNF
/// ```plain

39
src/http/header/macros.rs
View file

@ -1,13 +1,14 @@
macro_rules! common_header_test_module {
($id:ident, $tm:ident{$($tf:item)*}) => {
#[allow(unused_imports)]
#[cfg(test)]
mod $tm {
#![allow(unused_imports)]
use std::str;
use actix_http::http::Method;
use mime::*;
use $crate::http::header::*;
use super::$id as HeaderField;
use super::{$id as HeaderField, *};
$($tf)*
}
}
@ -50,7 +51,7 @@ macro_rules! common_header_test {
}
};
($id:ident, $raw:expr, $typed:expr) => {
($id:ident, $raw:expr, $exp:expr) => {
#[test]
fn $id() {
use actix_http::test;
@ -62,28 +63,31 @@ macro_rules! common_header_test {
}
let req = req.finish();
let val = HeaderField::parse(&req);
let typed: Option<HeaderField> = $typed;
let exp: Option<HeaderField> = $typed;
// Test parsing
assert_eq!(val.ok(), typed);
// test parsing
assert_eq!(val.ok(), exp);
// Test formatting
if typed.is_some() {
// test formatting
if let Some(exp) = exp {
let raw = &($raw)[..];
let mut iter = raw.iter().map(|b| str::from_utf8(&b[..]).unwrap());
let mut joined = String::new();
joined.push_str(iter.next().unwrap());
for s in iter {
joined.push_str(", ");
if let Some(s) = iter.next() {
joined.push_str(s);
for s in iter {
joined.push_str(", ");
joined.push_str(s);
}
}
assert_eq!(format!("{}", typed.unwrap()), joined);
assert_eq!(format!("{}", exp), joined);
}
}
};
}
macro_rules! common_header {
// TODO: these docs are wrong, there's no $n or $nn
// $attrs:meta: Attributes associated with the header item (usually docs)
// $id:ident: Identifier of the header
// $n:expr: Lowercase name of the header
@ -102,7 +106,7 @@ macro_rules! common_header {
}
#[inline]
fn parse<T: $crate::HttpMessage>(msg: &T) -> Result<Self, $crate::error::ParseError> {
fn parse<M: $crate::HttpMessage>(msg: &M) -> Result<Self, $crate::error::ParseError> {
let headers = msg.headers().get_all(Self::name());
$crate::http::header::from_comma_delimited(headers).map($id)
}
@ -133,16 +137,13 @@ macro_rules! common_header {
#[derive(Debug, Clone, PartialEq, Eq, ::derive_more::Deref, ::derive_more::DerefMut)]
pub struct $id(pub Vec<$item>);
impl $crate::http::header::Header for $id {
#[inline]
fn name() -> $crate::http::header::HeaderName {
$name
}
#[inline]
fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
where T: $crate::HttpMessage
{
fn parse<M: $crate::HttpMessage>(msg: &M) -> Result<Self, $crate::error::ParseError> {
$crate::http::header::from_comma_delimited(
msg.headers().get_all(Self::name())).map($id)
}
@ -180,7 +181,7 @@ macro_rules! common_header {
}
#[inline]
fn parse<T: $crate::HttpMessage>(msg: &T) -> Result<Self, $crate::error::ParseError> {
fn parse<M: $crate::HttpMessage>(msg: &M) -> Result<Self, $crate::error::ParseError> {
let header = msg.headers().get(Self::name());
$crate::http::header::from_one_raw_str(header).map($id)
}
@ -220,7 +221,7 @@ macro_rules! common_header {
}
#[inline]
fn parse<T: $crate::HttpMessage>(msg: &T) -> Result<Self, $crate::error::ParseError> {
fn parse<M: $crate::HttpMessage>(msg: &M) -> Result<Self, $crate::error::ParseError> {
let is_any = msg
.headers()
.get(Self::name())

3
src/http/header/mod.rs
View file

@ -22,7 +22,6 @@ mod accept_charset;
mod accept;
mod accept_language;
mod allow;
mod any_or_some;
mod cache_control;
mod content_disposition;
mod content_language;
@ -40,6 +39,7 @@ mod if_range;
mod if_unmodified_since;
mod last_modified;
mod macros;
mod preference;
// mod range;
#[cfg(test)]
@ -68,6 +68,7 @@ pub use self::if_none_match::IfNoneMatch;
pub use self::if_range::IfRange;
pub use self::if_unmodified_since::IfUnmodifiedSince;
pub use self::last_modified::LastModified;
pub use self::preference::Preference;
//pub use self::range::{Range, ByteRangeSpec};
/// Format writer ([`fmt::Write`]) for a [`BytesMut`].

70
src/http/header/preference.rs Normal file
View file

@ -0,0 +1,70 @@
use std::{
fmt::{self, Write as _},
str,
};
/// A wrapper for types used in header values where wildcard (`*`) items are allowed but the
/// underlying type does not support them.
///
/// For example, we use the `language-tags` crate for the [`AcceptLanguage`](super::AcceptLanguage)
/// typed header but it does not parse `*` successfully. On the other hand, the `mime` crate, used
/// for [`Accept`](super::Accept), has first-party support for wildcard items so this wrapper is not
/// used in those header types.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Hash)]
pub enum Preference<T> {
/// A wildcard value.
Any,
/// A valid `T`.
Specific(T),
}
impl<T> Preference<T> {
/// Returns true if preference is the any/wildcard (`*`) value.
pub fn is_any(&self) -> bool {
matches!(self, Self::Any)
}
/// Returns true if preference is the specific item (`T`) variant.
pub fn is_specific(&self) -> bool {
matches!(self, Self::Specific(_))
}
/// Returns reference to value in `Specific` variant, if it is set.
pub fn item(&self) -> Option<&T> {
match self {
Preference::Specific(ref item) => Some(item),
Preference::Any => None,
}
}
/// Consumes the container, returning the value in the `Specific` variant, if it is set.
pub fn into_item(self) -> Option<T> {
match self {
Preference::Specific(item) => Some(item),
Preference::Any => None,
}
}
}
impl<T: fmt::Display> fmt::Display for Preference<T> {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Preference::Any => f.write_char('*'),
Preference::Specific(item) => fmt::Display::fmt(item, f),
}
}
}
impl<T: str::FromStr> str::FromStr for Preference<T> {
type Err = T::Err;
#[inline]
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.trim() {
"*" => Ok(Self::Any),
other => other.parse().map(Preference::Specific),
}
}
}

4
src/http/header/range.rs
View file

@ -96,7 +96,7 @@ impl ByteRangeSpec {
/// simply ignore the range header and serve the full entity using a `200
/// OK` status code.
///
/// This function closely follows [RFC 7233][1] section 2.1.
/// This function closely follows [RFC 7233 §2.1].
/// As such, it considers ranges to be satisfiable if they meet the
/// following conditions:
///
@ -115,7 +115,7 @@ impl ByteRangeSpec {
/// value of last-byte-pos with a value that is one less than the current
/// length of the selected representation).
///
/// [1]: https://tools.ietf.org/html/rfc7233
/// [RFC 7233 §2.1]: https://datatracker.ietf.org/doc/html/rfc7233
pub fn to_satisfiable_range(&self, full_length: u64) -> Option<(u64, u64)> {
// If the full length is zero, there is no satisfiable end-inclusive range.
if full_length == 0 {