urly
Yet another URL library for ntex. The API is inspired by Python's yarl.
Url is a cheaply cloneable URL reference stored in a single ByteString.
General-purpose parsing normalizes the input, reusing its buffer when possible.
Url::parse_target instead preserves unvalidated HTTP request-target components.
Use Url::validate_target and Url::normalize for explicit validation and
normalization. Component setters normalize what they
replace, not other components of a raw target.
- Lenient parsing with normalization: percent-encoding, IDNA hosts, dot
segments and case.
Url::validatechecks strictly against RFC 3986. - Borrowed, percent-encoded accessors (
Scheme,Authority,Path,Query,Fragment) with methods to decode them. - Path helpers:
/operator,join,parent,file_name,extension. - Query helpers:
get,get_all,set_query_pairs,extend_query_pairs,update_query_pairs,remove_query_params. BuilderandPartsfor constructing URLs from components.quote,requoteandunquoteper URL component inurly::quoting.
Usage
[]
= "0.1"
use Url;
let url = from_static;
assert_eq!;
assert_eq!;
let users = &url / "users" / "john doe";
assert_eq!;
let mut url = users.join.unwrap;
url.extend_query_pairs;
assert_eq!;
let url = builder
.scheme
.host
.path
.query_pair
.build
.unwrap;
assert_eq!;
Requoting
Parsing requotes the input instead of encoding it again, so an already-encoded URL is normalized and parsing a normalized URL returns it unchanged:
- valid
%XXescapes are kept and their hex digits are uppercased - escapes of unreserved characters (
A-Z a-z 0-9 - . _ ~) are decoded - escapes of reserved characters are kept, so
%2Fin a path doesn't become a path separator and%3Bdoesn't become; - any other character that isn't allowed in the component is percent-encoded,
including non-ASCII characters (as UTF-8) and a
%that doesn't start a valid escape - a space is encoded as
%20, and as+in the query
Accessors return the percent-encoded component; use decode for the plain
value.
HTTP servers can defer validation and normalization:
use Url;
let mut target = parse_target.unwrap;
assert_eq!;
target.validate_target.unwrap;
target.normalize.unwrap;
assert_eq!;
parse_target accepts origin, absolute, authority and asterisk forms; the HTTP
server must enforce method-specific form restrictions. Parsing checks only
UTF-8, nonempty input and representation limits. validate_target rejects
malformed escapes, fragments, forbidden characters, invalid authorities and
encoded NULs before the query, without rewriting them. It accepts
browser-compatible unescaped path/query characters. Raw targets need not pass
strict RFC 3986 validation until validated and normalized.
For HTTP/2, Url::from_target_parts(scheme, authority, path_and_query) preserves
pseudo-header boundaries even when a malformed value contains delimiters.
Validate those components with validate_target, not by reparsing as_str().
use Url;
let url = parse_ref.unwrap;
assert_eq!;
assert_eq!;
assert_eq!;
urly::quoting applies the same rules to a single value: quote encodes a
literal value, requote normalizes an encoded one and unquote decodes it.
use ;
assert_eq!;
assert_eq!;
assert_eq!;
Features
http- conversions betweenUrlandhttp::Uriserde-SerializeandDeserializeforUrl
[]
= { = "0.1", = ["http", "serde"] }
License
- Apache License, Version 2.0, (LICENSE-APACHE or [http://www.apache.org/licenses/LICENSE-2.0])
- MIT license (LICENSE-MIT or [http://opensource.org/licenses/MIT])