From b3021e2acbbe59c77fe9c1be450310f26480510f Mon Sep 17 00:00:00 2001 From: Sergio Benitez Date: Fri, 19 Mar 2021 18:09:13 -0700 Subject: [PATCH] Fix all broken links. Update some outdated docs. --- contrib/lib/src/databases/error.rs | 2 + contrib/lib/src/helmet/policy.rs | 2 +- contrib/lib/src/uuid.rs | 4 +- core/codegen/src/lib.rs | 85 +++++++++++++++++----------- core/http/src/raw_str.rs | 7 +-- core/lib/src/catcher.rs | 2 +- core/lib/src/config/mod.rs | 2 +- core/lib/src/cookies.rs | 2 +- core/lib/src/data/temp_file.rs | 2 + core/lib/src/fairing/mod.rs | 2 +- core/lib/src/form/error.rs | 3 +- core/lib/src/form/from_form.rs | 2 + core/lib/src/form/validate.rs | 6 +- core/lib/src/request/from_request.rs | 4 +- core/lib/src/request/request.rs | 7 +-- core/lib/src/router/mod.rs | 2 + core/lib/src/router/uri.rs | 1 + site/guide/4-requests.md | 2 +- site/guide/5-responses.md | 2 - site/guide/8-testing.md | 69 +++++++++++++--------- site/guide/9-configuration.md | 2 +- 21 files changed, 122 insertions(+), 88 deletions(-) diff --git a/contrib/lib/src/databases/error.rs b/contrib/lib/src/databases/error.rs index 50882d74..42d6fd92 100644 --- a/contrib/lib/src/databases/error.rs +++ b/contrib/lib/src/databases/error.rs @@ -4,6 +4,8 @@ use rocket::figment; /// /// This type is only relevant to implementors of the [`Poolable`] trait. See /// the [`Poolable`] documentation for more information on how to use this type. +/// +/// [`Poolable`]: crate::databases::Poolable #[derive(Debug)] pub enum Error { /// A custom error of type `T`. diff --git a/contrib/lib/src/helmet/policy.rs b/contrib/lib/src/helmet/policy.rs index bae15009..9ecb340e 100644 --- a/contrib/lib/src/helmet/policy.rs +++ b/contrib/lib/src/helmet/policy.rs @@ -118,7 +118,7 @@ pub enum Referrer { NoReferrerWhenDowngrade, /// Only send the origin of part of the URL, e.g. the origin of - /// https://foo.com/bob.html is https://foo.com + /// `https://foo.com/bob.html` is `https://foo.com`. Origin, /// Send full URL for same-origin requests, only send origin part when diff --git a/contrib/lib/src/uuid.rs b/contrib/lib/src/uuid.rs index d3ca64a0..c269b09e 100644 --- a/contrib/lib/src/uuid.rs +++ b/contrib/lib/src/uuid.rs @@ -27,8 +27,8 @@ use rocket::form::{self, FromFormField, ValueField}; /// UUID data and form guard: consume UUID values. /// -/// `Uuid` implements [`FromParam`] and [`FromForm`], allowing UUID values to be -/// accepted directly in paths, queries, and forms. +/// `Uuid` implements [`FromParam`] and [`FromFormField`], allowing UUID values +/// to be accepted directly in paths, queries, and forms. /// /// # Usage /// diff --git a/core/codegen/src/lib.rs b/core/codegen/src/lib.rs index 79abafa8..3ec28d74 100644 --- a/core/codegen/src/lib.rs +++ b/core/codegen/src/lib.rs @@ -262,14 +262,14 @@ macro_rules! route_attribute { /// 3. A macro used by [`uri!`] to type-check and generate an /// [`Origin`]. /// - /// [`Handler`]: ../rocket/trait.Handler.html + /// [`Handler`]: rocket::handler::Handler /// [`routes!`]: macro.routes.html /// [`uri!`]: macro.uri.html - /// [`Origin`]: ../rocket/http/uri/struct.Origin.html - /// [`Outcome`]: ../rocket/outcome/enum.Outcome.html - /// [`Response`]: ../rocket/struct.Response.html - /// [`FromRequest` Outcomes]: ../rocket/request/trait.FromRequest.html#outcomes - /// [`FromData` Outcomes]: ../rocket/data/trait.FromData.html#outcomes + /// [`Origin`]: rocket::http::uri::Origin + /// [`Outcome`]: rocket::outcome::Outcome + /// [`Response`]: rocket::Response + /// [`FromRequest` Outcomes]: rocket::request::FromRequest#outcomes + /// [`FromData` Outcomes]: rocket::data::FromData#outcomes #[proc_macro_attribute] pub fn $name(args: TokenStream, input: TokenStream) -> TokenStream { emit!(attribute::route::route_attribute($method, args, input)) @@ -343,13 +343,13 @@ route_attribute!(options => Method::Options); /// name (the function's name) and status code from the route attribute or /// `None` if `default`. The handler is set to the generated handler. /// -/// [`&Request`]: ../rocket/struct.Request.html -/// [`Status`]: ../rocket/http/struct.Status.html -/// [`ErrorHandler`]: ../rocket/type.ErrorHandler.html +/// [`&Request`]: rocket::Request +/// [`Status`]: rocket::http::Status +/// [`ErrorHandler`]: rocket::catcher::ErrorHandler /// [`catchers!`]: macro.catchers.html -/// [`Catcher`]: ../rocket/struct.Catcher.html -/// [`Response`]: ../rocket/struct.Response.html -/// [`Responder`]: ../rocket/response/trait.Responder.html +/// [`Catcher`]: rocket::Catcher +/// [`Response`]: rocket::Response +/// [`Responder`]: rocket::Responder #[proc_macro_attribute] pub fn catch(args: TokenStream, input: TokenStream) -> TokenStream { emit!(attribute::catch::catch_attribute(args, input)) @@ -425,9 +425,8 @@ pub fn launch(args: TokenStream, input: TokenStream) -> TokenStream { /// variant. In the example above, the the strings `"fourth"`, `"FOUrth"` and so /// on would parse as `MyValue::Third`. /// -/// [`FromFormField`]: ../rocket/request/trait.FromFormField.html -/// [`FromFormField::Error`]: ../rocket/request/trait.FromFormField.html#associatedtype.Error -// FIXME(rustdoc): We should be able to refer to items in `rocket`. +/// [`FromFormField`]: rocket::form::FromFormField +/// [`FromFormField::Error`]: rocket::form::FromFormField::Error #[proc_macro_derive(FromFormField, attributes(field))] pub fn derive_from_form_field(input: TokenStream) -> TokenStream { emit!(derive::from_form_field::derive_from_form_field(input)) @@ -441,35 +440,43 @@ pub fn derive_from_form_field(input: TokenStream) -> TokenStream { /// # #[macro_use] extern crate rocket; /// # /// #[derive(FromForm)] -/// struct MyStruct { +/// struct MyStruct<'r> { /// field: usize, -/// other: String +/// #[field(name = "renamed_field")] +/// #[field(name = uncased("RenamedField"))] +/// other: &'r str, +/// #[field(validate = range(1..))] +/// r#type: usize, /// } /// ``` /// -/// Each field's type is required to implement [`FromFormField`]. +/// Each field's type is required to implement [`FromForm`]. /// /// The derive generates an implementation of the [`FromForm`] trait. The /// implementation parses a form whose field names match the field names of the /// structure on which the derive was applied. Each field's value is parsed with -/// the [`FromFormField`] implementation of the field's type. The `FromForm` -/// implementation succeeds only when all of the field parses succeed. If -/// parsing fails, an error ([`FromForm::Error`]) of type [`FormParseError`] is -/// returned. +/// the [`FromForm`] implementation of the field's type. The `FromForm` +/// implementation succeeds only when all of the field parses succeed or return +/// a default. Errors are collected into a [`form::Errors`] and return if +/// non-empty after parsing all fields. /// /// The derive accepts one field attribute: `field`, with the following syntax: /// /// ```text /// field := name? validate* /// -/// name := 'name' '=' '"' IDENT '"' +/// name := 'name' '=' name_val +/// name_val := '"' FIELD_NAME '"' +/// | 'uncased(' '"' FIELD_NAME '"' ') +/// /// validate := 'validate' '=' EXPR /// -/// IDENT := valid identifier, as defined by Rust +/// FIELD_NAME := valid field name, according to the HTML5 spec /// EXPR := valid expression, as defined by Rust /// ``` /// -/// When applied, the attribute looks as follows: +/// The attribute can be applied any number of times on a field. When applied, +/// the attribute looks as follows: /// /// ```rust /// # #[macro_use] extern crate rocket; @@ -478,20 +485,30 @@ pub fn derive_from_form_field(input: TokenStream) -> TokenStream { /// struct MyStruct { /// field: usize, /// #[field(name = "renamed_field")] +/// #[field(name = uncased("anotherName"))] +/// #[field(validate = eq("banana"))] +/// #[field(validate = neq("orange"))] /// other: String /// } /// ``` /// -/// The field attribute directs that a different incoming field name is -/// expected, the value of `name`, which is used instead of the structure's -/// actual field name when parsing a form. In the example above, the value of -/// the `MyStruct::other` struct field will be parsed from the incoming form's -/// `renamed_field` field. +/// **`name`** /// -/// [`FromForm`]: ../rocket/request/trait.FromForm.html -/// [`FromFormField`]: ../rocket/request/trait.FromFormField.html -/// [`FormParseError`]: ../rocket/request/enum.FormParseError.html -/// [`FromForm::Error`]: ../rocket/request/trait.FromForm.html#associatedtype.Error +/// A `name` attribute changes the name to match against when parsing the form +/// field. The value is either an exact string to match against (`"foo"`), or +/// `uncased("foo")`, which causes the match to be case-insensitive but +/// case-preserving. When more than one `name` attribute is applied, the field +/// will match against _any_ of the names. +/// +/// **`validate`** +/// +/// The validation expression will be run if the field type parses successfully. +/// The expression must return a value of type `Result<(), form::Errors>`. On +/// `Err`, the errors are added to the thus-far collected errors. If more than +/// one `validate` attribute is applied, _all_ validations are run. +/// +/// [`FromForm`]: rocket::form::FromForm +/// [`form::Errors`]: rocket::form::Errors #[proc_macro_derive(FromForm, attributes(field))] pub fn derive_from_form(input: TokenStream) -> TokenStream { emit!(derive::from_form::derive_from_form(input)) diff --git a/core/http/src/raw_str.rs b/core/http/src/raw_str.rs index fb0f6b88..7e0a3166 100644 --- a/core/http/src/raw_str.rs +++ b/core/http/src/raw_str.rs @@ -45,12 +45,7 @@ use crate::uncased::UncasedStr; /// # Usage /// /// A `RawStr` is a dynamically sized type (just like `str`). It is always used -/// through a reference an as `&RawStr` (just like &str). You'll likely -/// encounter an `&RawStr` as a parameter via [`FromParam`] or as a form value -/// via [`FromFormValue`]. -/// -/// [`FromParam`]: rocket::request::FromParam -/// [`FromFormValue`]: rocket::request::FromFormValue +/// through a reference an as `&RawStr` (just like &str). #[repr(transparent)] #[derive(RefCast, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct RawStr(str); diff --git a/core/lib/src/catcher.rs b/core/lib/src/catcher.rs index b7cdf0ad..070e7545 100644 --- a/core/lib/src/catcher.rs +++ b/core/lib/src/catcher.rs @@ -95,7 +95,7 @@ pub type ErrorHandlerFuture<'r> = BoxFuture<'r, Result<'r>>; /// /// See the [`catch`] documentation for full details. /// -/// [`catch`]: rocket_codegen::catch +/// [`catch`]: crate::catch /// [`Responder`]: crate::response::Responder /// [`&Request`]: crate::request::Request /// [`Status`]: crate::http::Status diff --git a/core/lib/src/config/mod.rs b/core/lib/src/config/mod.rs index 14231f31..105a7149 100644 --- a/core/lib/src/config/mod.rs +++ b/core/lib/src/config/mod.rs @@ -46,7 +46,7 @@ //! A custom provider can be set via [`rocket::custom()`], which replaces calls to //! [`rocket::ignite()`]. The configured provider can be built on top of //! [`Config::figment()`], [`Config::default()`], both, or neither. The -//! [Figment](@figment) documentation has full details on instantiating existing +//! [Figment](figment) documentation has full details on instantiating existing //! providers like [`Toml`]() and [`Env`] as well as creating custom providers for //! more complex cases. //! diff --git a/core/lib/src/cookies.rs b/core/lib/src/cookies.rs index e9b374b4..72bddf92 100644 --- a/core/lib/src/cookies.rs +++ b/core/lib/src/cookies.rs @@ -66,7 +66,7 @@ pub use self::cookie::{Cookie, SameSite, Iter}; /// [`add()`], [`add_private()`], [`remove()`], and [`remove_private()`] /// methods. /// -/// [`Request::cookies()`]: rocket::Request::cookies() +/// [`Request::cookies()`]: crate::Request::cookies() /// [`get()`]: #method.get /// [`get_private()`]: #method.get_private /// [`get_pending()`]: #method.get_pending diff --git a/core/lib/src/data/temp_file.rs b/core/lib/src/data/temp_file.rs index 2ddbd503..0038433e 100644 --- a/core/lib/src/data/temp_file.rs +++ b/core/lib/src/data/temp_file.rs @@ -47,6 +47,8 @@ use either::Either; /// | `limits.file` | 1MiB | Default limit for all file extensions. | /// | `limits.file/$ext` | _N/A_ | Limit for files with extension `$ext`. | /// +/// [`env::temp_dir()`]: std::env::temp_dir() +/// /// When used as a form guard, the extension `$ext` is identified by the form /// field's `Content-Type` ([`ContentType::extension()`]). When used as a data /// guard, the extension is identified by the Content-Type of the request, if diff --git a/core/lib/src/fairing/mod.rs b/core/lib/src/fairing/mod.rs index 386a2e81..d90c0809 100644 --- a/core/lib/src/fairing/mod.rs +++ b/core/lib/src/fairing/mod.rs @@ -233,7 +233,7 @@ pub use self::info_kind::{Info, Kind}; /// /// Imagine that we want to record the number of `GET` and `POST` requests that /// our application has received. While we could do this with [request guards] -/// and [managed state](crate::request::State), it would require us to annotate every +/// and [managed state](crate::State), it would require us to annotate every /// `GET` and `POST` request with custom types, polluting handler signatures. /// Instead, we can create a simple fairing that acts globally. /// diff --git a/core/lib/src/form/error.rs b/core/lib/src/form/error.rs index 97e90df4..02acc19e 100644 --- a/core/lib/src/form/error.rs +++ b/core/lib/src/form/error.rs @@ -339,7 +339,8 @@ impl<'v> Errors<'v> { /// Returns the highest [`Error::status()`] of all of the errors in `self` /// or [`Status::InternalServerError`] if `self` is empty. This is the - /// status that is set by the [`Form`] data guard on failure. + /// status that is set by the [`Form`](crate::form::Form) data guard on + /// failure. /// /// # Example /// diff --git a/core/lib/src/form/from_form.rs b/core/lib/src/form/from_form.rs index d6434af6..82237545 100644 --- a/core/lib/src/form/from_form.rs +++ b/core/lib/src/form/from_form.rs @@ -42,6 +42,8 @@ use crate::http::uncased::AsUncased; /// [`FromForm`]. Form fields with the struct field's name are [shifted] and /// then pushed to the struct field's `FromForm` parser. /// +/// [shifted]: NameView::shift() +/// /// ```rust /// use rocket::form::FromForm; /// diff --git a/core/lib/src/form/validate.rs b/core/lib/src/form/validate.rs index c06afd74..00790c0f 100644 --- a/core/lib/src/form/validate.rs +++ b/core/lib/src/form/validate.rs @@ -284,7 +284,7 @@ impl> Len for Result<'_, T> { /// The value must implement [`Len`]. On failure, returns an [`InvalidLength`] /// error. See [`Len`] for supported types and how their length is computed. /// -/// [`InvalidLength`]: rocket::form::error::ErrorKind::InvalidLength +/// [`InvalidLength`]: crate::form::error::ErrorKind::InvalidLength /// /// # Data Limits /// @@ -559,7 +559,7 @@ pub fn verbose_omits<'v, V, I>(value: V, item: I) -> Result<'v, ()> /// The value must be an integer type that implement `TryInto + Copy`. On /// failure, returns an [`OutOfRange`] error. /// -/// [`OutOfRange`]: rocket::form::error::ErrorKind::OutOfRange +/// [`OutOfRange`]: crate::form::error::ErrorKind::OutOfRange /// /// # Example /// @@ -609,7 +609,7 @@ pub fn range<'v, V, R>(value: &V, range: R) -> Result<'v, ()> /// On failure, returns a [`InvalidChoice`] error with the debug representation /// of each item in `items`. /// -/// [`InvalidChoice`]: rocket::form::error::ErrorKind::InvalidChoice +/// [`InvalidChoice`]: crate::form::error::ErrorKind::InvalidChoice /// /// # Example /// diff --git a/core/lib/src/request/from_request.rs b/core/lib/src/request/from_request.rs index 084fe006..c5ed2d38 100644 --- a/core/lib/src/request/from_request.rs +++ b/core/lib/src/request/from_request.rs @@ -146,7 +146,7 @@ impl IntoOutcome for Result { /// /// _This implementation always returns successfully._ /// -/// * **&[`Config`](crate::config::Config)** +/// * **&[`Config`]** /// /// Extracts the application [`Config`]. /// @@ -185,6 +185,8 @@ impl IntoOutcome for Result { /// returned in `Err`. If the derivation is a `Forward`, the request is /// forwarded. /// +/// [`Config`]: crate::config::Config +/// /// # Example /// /// Imagine you're running an authenticated API service that requires that some diff --git a/core/lib/src/request/request.rs b/core/lib/src/request/request.rs index 5c0f8fd1..8deaac3c 100644 --- a/core/lib/src/request/request.rs +++ b/core/lib/src/request/request.rs @@ -695,9 +695,8 @@ impl<'r> Request<'r> { } /// Retrieves and parses into `T` the query value with field name `name`. - /// `T` must implement [`FromFormValue`], which is used to parse the query's - /// value. Key matching is performed case-sensitively. If there are multiple - /// pairs with key `key`, the _first_ one is returned. + /// `T` must implement [`FromForm`], which is used to parse the query's + /// value. Key matching is performed case-sensitively. /// /// # Warning /// @@ -710,7 +709,7 @@ impl<'r> Request<'r> { /// # Error /// /// If a query segment with name `name` isn't present, returns `None`. If - /// parsing the value fails, returns `Some(Err(T:Error))`. + /// parsing the value fails, returns `Some(Err(_))`. /// /// # Example /// diff --git a/core/lib/src/router/mod.rs b/core/lib/src/router/mod.rs index c203ac86..a25fe35c 100644 --- a/core/lib/src/router/mod.rs +++ b/core/lib/src/router/mod.rs @@ -1,3 +1,5 @@ +//! Routing types: [`Route`] and [`RouteUri`]. + mod collider; mod route; mod segment; diff --git a/core/lib/src/router/uri.rs b/core/lib/src/router/uri.rs index efabc658..d4fb81bb 100644 --- a/core/lib/src/router/uri.rs +++ b/core/lib/src/router/uri.rs @@ -52,6 +52,7 @@ use crate::router::segment::Segment; /// ``` /// /// [`Rocket::mount()`]: crate::Rocket::mount() +/// [`Route::new()`]: crate::Route::new() #[derive(Clone)] pub struct RouteUri<'a> { /// The source string for this URI. diff --git a/site/guide/4-requests.md b/site/guide/4-requests.md index 5579cc28..130dd2fe 100644 --- a/site/guide/4-requests.md +++ b/site/guide/4-requests.md @@ -935,7 +935,7 @@ struct MyForm<'v> { # rocket_guide_tests::assert_form_parses_ok!(MyForm, ""); ``` -[`Errors<'_>`]: @api/rocket/forms/struct.Errors.html +[`Errors<'_>`]: @api/rocket/form/struct.Errors.html ### Collections diff --git a/site/guide/5-responses.md b/site/guide/5-responses.md index 2baddcf9..3f304c7f 100644 --- a/site/guide/5-responses.md +++ b/site/guide/5-responses.md @@ -278,7 +278,6 @@ library. Among these are: * [`Json`] - Automatically serializes values into JSON. * [`MsgPack`] - Automatically serializes values into MessagePack. * [`Template`] - Renders a dynamic template using handlebars or Tera. - * [`Compress`] - Compresses a response at the HTTP layer. [`status`]: @api/rocket/response/status/ [`response`]: @api/rocket/response/ @@ -288,7 +287,6 @@ library. Among these are: [`Stream`]: @api/rocket/response/struct.Stream.html [`Flash`]: @api/rocket/response/struct.Flash.html [`MsgPack`]: @api/rocket_contrib/msgpack/struct.MsgPack.html -[`Compress`]: @api/rocket_contrib/compression/struct.Compress.html ### Streaming diff --git a/site/guide/8-testing.md b/site/guide/8-testing.md index e5da4bc3..58d09150 100644 --- a/site/guide/8-testing.md +++ b/site/guide/8-testing.md @@ -50,33 +50,32 @@ instance. Usage is straightforward: ``` [`local`]: @api/rocket/local/ -[`Client`]: @api/rocket/local/struct.Client.html -[`LocalRequest`]: @api/rocket/local/struct.LocalRequest.html +[`Client`]: @api/rocket/local/#client +[`LocalRequest`]: @api/rocket/local/#localrequest [`Rocket`]: @api/rocket/struct.Rocket.html ## Validating Responses -A `dispatch` of a `LocalRequest` returns a [`LocalResponse`] which can be used -transparently as a [`Response`] value. During testing, the response is usually -validated against expected properties. These includes things like the response -HTTP status, the inclusion of headers, and expected body data. +A `dispatch` of a `LocalRequest` returns a [`LocalResponse`] which can be +inspected for validaty. During testing, the response is usually validated +against expected properties. These includes things like the response HTTP +status, the inclusion of headers, and expected body data. -The [`Response`] type provides methods to ease this sort of validation. We list +[`LocalResponse`] type provides methods to ease this sort of validation. We list a few below: * [`status`]: returns the HTTP status in the response. * [`content_type`]: returns the Content-Type header in the response. * [`headers`]: returns a map of all of the headers in the response. - * [`body_string`]: returns the body data as a `String`. - * [`body_bytes`]: returns the body data as a `Vec`. + * [`into_string`]: reads the body data into a `String`. + * [`into_bytes`]: reads the body data into a `Vec`. -[`LocalResponse`]: @api/rocket/local/struct.LocalResponse.html -[`Response`]: @api/rocket/struct.Response.html -[`status`]: @api/rocket/struct.Response.html#method.status -[`content_type`]: @api/rocket/struct.Response.html#method.content_type -[`headers`]: @api/rocket/struct.Response.html#method.headers -[`body_string`]: @api/rocket/struct.Response.html#method.body_string -[`body_bytes`]: @api/rocket/struct.Response.html#method.body_bytes +[`LocalResponse`]: @api/rocket/local/blocking/struct.LocalResponse.html +[`status`]: @api/rocket/local/blocking/struct.LocalResponse.html#method.status +[`content_type`]: @api/rocket/local/blocking/struct.LocalResponse.html#method.content_type +[`headers`]: @api/rocket/local/blocking/struct.LocalResponse.html#method.headers +[`into_string`]: @api/rocket/local/blocking/struct.LocalResponse.html#method.into_string +[`into_bytes`]: @api/rocket/local/blocking/struct.LocalResponse.html#method.into_bytes These methods are typically used in combination with the `assert_eq!` or `assert!` macros as follows: @@ -283,18 +282,32 @@ During compilation, you should see output like: ```rust,ignore note: emitting Rocket code generation debug output - --> examples/hello_world/src/main.rs:7:1 - | -7 | #[get("/")] - | ^^^^^^^^^^^ - | - = note: - fn rocket_route_fn_hello<'_b>( - __req: &'_b ::rocket::Request, - __data: ::rocket::Data - ) -> ::rocket::handler::Outcome<'_b> { - let responder = hello(); - ::rocket::handler::Outcome::from(__req, responder) + --> examples/hello_world/src/main.rs:14:1 + | +14 | #[get("/world")] + | ^^^^^^^^^^^^^^^^ + | + = note: + impl From for rocket::StaticRouteInfo { + fn from(_: world) -> rocket::StaticRouteInfo { + fn monomorphized_function<'_b>( + __req: &'_b rocket::request::Request<'_>, + __data: rocket::data::Data, + ) -> rocket::handler::HandlerFuture<'_b> { + ::std::boxed::Box::pin(async move { + let ___responder = world(); + rocket::handler::Outcome::from(__req, ___responder) + }) + } + rocket::StaticRouteInfo { + name: "world", + method: ::rocket::http::Method::Get, + path: "/world", + handler: monomorphized_function, + format: ::std::option::Option::None, + rank: ::std::option::Option::None, + } + } } ``` diff --git a/site/guide/9-configuration.md b/site/guide/9-configuration.md index 528cb24e..7f66d2a3 100644 --- a/site/guide/9-configuration.md +++ b/site/guide/9-configuration.md @@ -53,7 +53,7 @@ selected profile doesn't contain a requested values, while values in the [`Provider`]: @figment/trait.Provider.html [`Profile`]: @figment/struct.Profile.html [`Config`]: @api/rocket/struct.Config.html -[`Config::figment()`]: @api/struct.Config.html#method.figment +[`Config::figment()`]: @api/rocket/struct.Config.html#method.figment [`Toml`]: @figment/providers/struct.Toml.html [`Json`]: @figment/providers/struct.Json.html [`Figment`]: @api/rocket/struct.Figment.html