WHATWG URL parser for Rust

Fast WHATWG URL Specification compliant URL parser for Rust. Well-tested and widely used by Node.js since Node 18.

The Ada library passes the full range of tests from the specification, across a wide range of platforms (e.g., Windows, Linux, macOS). It fully supports the relevant Unicode Technical Standard.

Usage

Here is an example illustrating a common usage:

use ada_url::Url;
fn main() {
    let u = Url::parse("http://www.google:8080/love#drug", None).expect("bad url");
    println!("port: {:?}", u.port());
    println!("hash: {:?}", u.hash());
    println!("pathname: {:?}", u.pathname());
    println!("href: {:?}", u.href());
    u.set_port("9999");
    println!("href: {:?}", u.href());
}

Features

std: Functionalities that require std. This feature is enabled by default, set no-default-features to true if you want no-std.

serde: Allow Url to work with serde. This feature is disabled by default. Enabling this feature without std would provide you only Serialize. Enabling this feature and std would provide you both Serialize and Deserialize.

libcpp: Build ada-url with libc++. This feature is disabled by default. Enabling this feature without libc++ installed would cause compile error.

Performance

Ada is fast. The benchmark below shows 3.34 times faster URL parsing compared to url

parse/ada_url           time:   [2.0790 µs 2.0812 µs 2.0835 µs]
                        thrpt:  [369.84 MiB/s 370.25 MiB/s 370.65 MiB/s]

parse/url               time:   [6.9266 µs 6.9677 µs 7.0199 µs]
                        thrpt:  [109.77 MiB/s 110.59 MiB/s 111.25 MiB/s]

Implemented traits

Url implements the following traits.

Trait(s)	Description
`Display`	Provides `to_string` and allows for the value to be used in format! macros (e.g. `println!`).
`Debug`	Allows debugger output in format macros, (`{:?}` syntax)
`PartialEq`, `Eq`	Allows for comparison, `url1 == url2`, `url1.eq(url2)`
`PartialOrd`, `Ord`	Allows for ordering `url1 < url2`, done so alphabetically. This is also allows `Url` to be used as a key in a `BTreeMap`
`Hash`	Makes it so that `Url` can be hashed based on the string representation. This is important so that `Url` can be used as a key in a `HashMap`
`FromStr`	Allows for use with `str`'s `parse` method
`TryFrom<String>`, `TryFrom<&str>`	Provides `try_into` methods for `String` and `&str`
`Borrow<str>`, `Borrow<[u8]>`	Used in some crates so that the `Url` can be used as a key.
`Deref<Target=str>`	Allows for `&Url` to dereference as a `&str`. Also provides a number of string methods
`AsRef<[u8]>`, `AsRef<str>`	Used to do a cheap reference-to-reference conversion.
`Send`	Used to declare that the type can be transferred across thread boundaries.
`Sync`	Used to declare that the type is thread-safe.

Development

`justfile`

The justfile contains commands (called "recipes") that can be executed by just for convenience.

Run all lints and tests:

just all

Skipping features:

just all --skip=libcpp,serde

License

This code is made available under the Apache License 2.0 as well as the MIT license.

Our tests include third-party code and data. The benchmarking code includes third-party code: it is provided for research purposes only and not part of the library.

License

KSXGitHub/rust-ada-url

ErrorLooks like something went wrong!

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

Error
Looks like something went wrong!

Packages