18 |
Success!
19 |
20 |
Submission Data
21 |
22 |
23 | {% for key, value in values %}
24 | - {{ key }} - {{ value }}
25 | {% endfor %}
26 |
27 |
28 |
< Submit Another
29 |
30 |
31 |
--------------------------------------------------------------------------------
/core/lib/tests/session-cookies-issue-1506.rs:
--------------------------------------------------------------------------------
1 | #![cfg(feature = "secrets")]
2 |
3 | use rocket::http::{CookieJar, Cookie};
4 |
5 | #[rocket::get("/")]
6 | fn index(jar: &CookieJar<'_>) {
7 | let session_cookie = Cookie::build("key", "value").expires(None);
8 | jar.add_private(session_cookie.finish());
9 | }
10 |
11 | mod test_session_cookies {
12 | use super::*;
13 | use rocket::local::blocking::Client;
14 |
15 | #[test]
16 | fn session_cookie_is_session() {
17 | let rocket = rocket::build().mount("/", rocket::routes![index]);
18 | let client = Client::debug(rocket).unwrap();
19 |
20 | let response = client.get("/").dispatch();
21 | let cookie = response.cookies().get_private("key").unwrap();
22 | assert_eq!(cookie.expires_datetime(), None);
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/core/lib/fuzz/targets/uri-parsing.rs:
--------------------------------------------------------------------------------
1 | #![no_main]
2 |
3 | use rocket::http::uri::*;
4 | use libfuzzer_sys::fuzz_target;
5 |
6 | fn fuzz(data: &str) {
7 | // Fuzz the top-level parser.
8 | if let Ok(uri) = Uri::parse_any(data) {
9 | // Ensure Uri::parse::
() => T::parse().
10 | match uri {
11 | Uri::Asterisk(_) => { Asterisk::parse(data).expect("Asterisk"); },
12 | Uri::Origin(_) => { Origin::parse(data).expect("Origin"); },
13 | Uri::Authority(_) => { Authority::parse(data).expect("Authority"); },
14 | Uri::Absolute(_) => { Absolute::parse(data).expect("Absolute"); },
15 | Uri::Reference(_) => { Reference::parse(data).expect("Reference"); },
16 | }
17 | }
18 | }
19 |
20 | fuzz_target!(|data: &[u8]| {
21 | let _ = std::str::from_utf8(data).map(fuzz);
22 | });
23 |
--------------------------------------------------------------------------------
/examples/static-files/src/main.rs:
--------------------------------------------------------------------------------
1 | #[cfg(test)] mod tests;
2 |
3 | use rocket::fs::{FileServer, relative};
4 |
5 | // If we wanted or needed to serve files manually, we'd use `NamedFile`. Always
6 | // prefer to use `FileServer`!
7 | mod manual {
8 | use std::path::{PathBuf, Path};
9 | use rocket::fs::NamedFile;
10 |
11 | #[rocket::get("/second/")]
12 | pub async fn second(path: PathBuf) -> Option {
13 | let mut path = Path::new(super::relative!("static")).join(path);
14 | if path.is_dir() {
15 | path.push("index.html");
16 | }
17 |
18 | NamedFile::open(path).await.ok()
19 | }
20 | }
21 |
22 | #[rocket::launch]
23 | fn rocket() -> _ {
24 | rocket::build()
25 | .mount("/", rocket::routes![manual::second])
26 | .mount("/", FileServer::from(relative!("static")))
27 | }
28 |
--------------------------------------------------------------------------------
/contrib/db_pools/codegen/tests/ui-fail/database-syntax.rs:
--------------------------------------------------------------------------------
1 | use rocket_db_pools::{deadpool_postgres, Database};
2 |
3 | #[derive(Database)]
4 | #[database(123)]
5 | struct A(deadpool_postgres::Pool);
6 |
7 | #[derive(Database)]
8 | #[database("some-name", "another")]
9 | struct B(deadpool_postgres::Pool);
10 |
11 | #[derive(Database)]
12 | #[database("some-name", name = "another")]
13 | struct C(deadpool_postgres::Pool);
14 |
15 | #[derive(Database)]
16 | #[database("foo")]
17 | enum D { }
18 |
19 | #[derive(Database)]
20 | struct E(deadpool_postgres::Pool);
21 |
22 | #[derive(Database)]
23 | #[database("foo")]
24 | struct F;
25 |
26 | #[derive(Database)]
27 | #[database("foo")]
28 | struct G(deadpool_postgres::Pool, deadpool_postgres::Pool);
29 |
30 | #[derive(Database)]
31 | #[database("foo")]
32 | struct H {
33 | foo: deadpool_postgres::Pool,
34 | }
35 |
36 | fn main() { }
37 |
--------------------------------------------------------------------------------
/contrib/db_pools/codegen/tests/ui-fail-stable/database-types.stderr:
--------------------------------------------------------------------------------
1 | error[E0277]: the trait bound `Unknown: Pool` is not satisfied
2 | --> $DIR/database-types.rs:7:10
3 | |
4 | 7 | struct A(Unknown);
5 | | ^^^^^^^ the trait `Pool` is not implemented for `Unknown`
6 | |
7 | ::: $WORKSPACE/contrib/db_pools/lib/src/database.rs
8 | |
9 | | type Pool: Pool;
10 | | ---- required by this bound in `rocket_db_pools::Database::Pool`
11 |
12 | error[E0277]: the trait bound `Vec: Pool` is not satisfied
13 | --> $DIR/database-types.rs:11:10
14 | |
15 | 11 | struct B(Vec);
16 | | ^^^ the trait `Pool` is not implemented for `Vec`
17 | |
18 | ::: $WORKSPACE/contrib/db_pools/lib/src/database.rs
19 | |
20 | | type Pool: Pool;
21 | | ---- required by this bound in `rocket_db_pools::Database::Pool`
22 |
--------------------------------------------------------------------------------
/core/lib/fuzz/targets/uri-roundtrip.rs:
--------------------------------------------------------------------------------
1 | #![no_main]
2 |
3 | use rocket::http::uri::*;
4 | use libfuzzer_sys::fuzz_target;
5 |
6 | fn fuzz(data: &str) {
7 | if let Ok(uri) = Uri::parse_any(data) {
8 | let string = uri.to_string();
9 | let _ = match uri {
10 | Uri::Asterisk(_) => Asterisk::parse_owned(string).expect("Asterisk").to_string(),
11 | Uri::Origin(_) => Origin::parse_owned(string).expect("Origin").to_string(),
12 | Uri::Authority(_) => Authority::parse_owned(string).expect("Authority").to_string(),
13 | Uri::Absolute(_) => Absolute::parse_owned(string).expect("Absolute").to_string(),
14 | Uri::Reference(_) => Reference::parse_owned(string).expect("Reference").to_string(),
15 | };
16 | }
17 | }
18 |
19 | fuzz_target!(|data: &[u8]| {
20 | let _ = std::str::from_utf8(data).map(fuzz);
21 | });
22 |
--------------------------------------------------------------------------------
/core/lib/tests/can-launch-tls.rs:
--------------------------------------------------------------------------------
1 | #![cfg(feature = "tls")]
2 |
3 | use rocket::fs::relative;
4 | use rocket::config::{Config, TlsConfig, CipherSuite};
5 | use rocket::local::asynchronous::Client;
6 |
7 | #[rocket::async_test]
8 | async fn can_launch_tls() {
9 | let cert_path = relative!("examples/tls/private/rsa_sha256_cert.pem");
10 | let key_path = relative!("examples/tls/private/rsa_sha256_key.pem");
11 |
12 | let tls = TlsConfig::from_paths(cert_path, key_path)
13 | .with_ciphers([
14 | CipherSuite::TLS_AES_128_GCM_SHA256,
15 | CipherSuite::TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
16 | ]);
17 |
18 | let rocket = rocket::custom(Config { tls: Some(tls), ..Config::debug_default() });
19 | let client = Client::debug(rocket).await.unwrap();
20 |
21 | client.rocket().shutdown().notify();
22 | client.rocket().shutdown().await;
23 | }
24 |
--------------------------------------------------------------------------------
/examples/cookies/src/message.rs:
--------------------------------------------------------------------------------
1 | use rocket::form::Form;
2 | use rocket::response::Redirect;
3 | use rocket::http::{Cookie, CookieJar};
4 | use rocket_dyn_templates::{Template, context};
5 |
6 | #[macro_export]
7 | macro_rules! message_uri {
8 | ($($t:tt)*) => (rocket::uri!("/message", $crate::message:: $($t)*))
9 | }
10 |
11 | pub use message_uri as uri;
12 |
13 | #[post("/", data = "")]
14 | fn submit(cookies: &CookieJar<'_>, message: Form<&str>) -> Redirect {
15 | cookies.add(Cookie::new("message", message.to_string()));
16 | Redirect::to(uri!(index))
17 | }
18 |
19 | #[get("/")]
20 | fn index(cookies: &CookieJar<'_>) -> Template {
21 | let cookie = cookies.get("message");
22 |
23 | Template::render("message", context! {
24 | message: cookie.map(|c| c.value()),
25 | })
26 | }
27 |
28 | pub fn routes() -> Vec {
29 | routes![submit, index]
30 | }
31 |
--------------------------------------------------------------------------------
/examples/config/src/main.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | #[cfg(test)] mod tests;
4 |
5 | use rocket::{State, Config};
6 | use rocket::fairing::AdHoc;
7 | use rocket::serde::Deserialize;
8 |
9 | #[derive(Debug, Deserialize)]
10 | #[serde(crate = "rocket::serde")]
11 | struct AppConfig {
12 | key: String,
13 | port: u16
14 | }
15 |
16 | #[get("/")]
17 | fn read_config(rocket_config: &Config, app_config: &State) -> String {
18 | format!("{:#?}\n{:#?}", app_config, rocket_config)
19 | }
20 |
21 | // See Rocket.toml file. Running this server will print the config. Try running
22 | // with `ROCKET_PROFILE=release` manually by setting the environment variable
23 | // and automatically by compiling with `--release`.
24 | #[launch]
25 | fn rocket() -> _ {
26 | rocket::build()
27 | .mount("/", routes![read_config])
28 | .attach(AdHoc::config::())
29 | }
30 |
--------------------------------------------------------------------------------
/core/lib/tests/tls-config-from-source-1503.rs:
--------------------------------------------------------------------------------
1 | #![cfg(feature = "tls")]
2 |
3 | macro_rules! relative {
4 | ($path:expr) => {
5 | std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/", $path))
6 | };
7 | }
8 |
9 | #[test]
10 | fn tls_config_from_source() {
11 | use rocket::config::{Config, TlsConfig};
12 | use rocket::figment::Figment;
13 |
14 | let cert_path = relative!("examples/tls/private/cert.pem");
15 | let key_path = relative!("examples/tls/private/key.pem");
16 |
17 | let rocket_config = Config {
18 | tls: Some(TlsConfig::from_paths(cert_path, key_path)),
19 | ..Default::default()
20 | };
21 |
22 | let config: Config = Figment::from(rocket_config).extract().unwrap();
23 | let tls = config.tls.expect("have TLS config");
24 | assert_eq!(tls.certs().unwrap_left(), cert_path);
25 | assert_eq!(tls.key().unwrap_left(), key_path);
26 | }
27 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/suggestion.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Suggestion
3 | about: Suggest a change or improvement to existing functionality
4 | title: ''
5 | labels: suggestion
6 | assignees: ''
7 | ---
8 |
9 | **Existing Functionality**
10 |
11 | A clear and concise description of existing functionality and why it is insufficient. Examples:
12 |
13 | - "I frequently want to do X, but Rocket makes it hard. It would be nice if..."
14 | - "Feature Z exists, but it has these drawbacks. What if..."
15 |
16 | **Suggested Changes**
17 |
18 | If you have a conrete idea for an improvement, propose it with a clear and concise description.
19 |
20 | **Alternatives Considered**
21 |
22 | A clear and concise description of any alternative solutions using existing features or new features you've considered.
23 |
24 | **Additional Context**
25 |
26 | Add any other context here, for example, descriptions of elegant solutions in other software.
27 |
--------------------------------------------------------------------------------
/examples/templating/src/main.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | mod hbs;
4 | mod tera;
5 |
6 | #[cfg(test)] mod tests;
7 |
8 | use rocket::response::content::RawHtml;
9 | use rocket_dyn_templates::Template;
10 |
11 | #[get("/")]
12 | fn index() -> RawHtml<&'static str> {
13 | RawHtml(r#"See Tera or Handlebars."#)
14 | }
15 |
16 | #[launch]
17 | fn rocket() -> _ {
18 | rocket::build()
19 | .mount("/", routes![index])
20 | .mount("/tera", routes![tera::index, tera::hello, tera::about])
21 | .mount("/hbs", routes![hbs::index, hbs::hello, hbs::about])
22 | .register("/hbs", catchers![hbs::not_found])
23 | .register("/tera", catchers![tera::not_found])
24 | .attach(Template::custom(|engines| {
25 | hbs::customize(&mut engines.handlebars);
26 | tera::customize(&mut engines.tera);
27 | }))
28 | }
29 |
--------------------------------------------------------------------------------
/examples/cookies/templates/login.html.hbs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Rocket: Sessions
7 |
8 |
9 | Rocket Session: Please Login
10 |
11 | Please login to continue.
12 |
13 | {{#if message}}
14 | {{#if kind}}{{kind}}: {{/if}}{{ message }}
15 | {{/if}}
16 |
17 |
24 |
25 | Home
26 |
27 |
28 |
--------------------------------------------------------------------------------
/core/lib/tests/responder_lifetime-issue-345.rs:
--------------------------------------------------------------------------------
1 | #![allow(dead_code)] // This test is only here so that we can ensure it compiles.
2 |
3 | #[macro_use] extern crate rocket;
4 |
5 | use rocket::{Request, State};
6 | use rocket::response::{Responder, Result};
7 |
8 | struct SomeState;
9 |
10 | pub struct CustomResponder<'r, R> {
11 | responder: R,
12 | state: &'r SomeState,
13 | }
14 |
15 | impl<'r, 'o: 'r, R: Responder<'r, 'o>> Responder<'r, 'o> for CustomResponder<'r, R> {
16 | fn respond_to(self, req: &'r Request<'_>) -> Result<'o> {
17 | self.responder.respond_to(req)
18 | }
19 | }
20 |
21 | #[get("/unit_state")]
22 | fn unit_state(state: &State) -> CustomResponder<()> {
23 | CustomResponder { responder: (), state: &*state }
24 | }
25 |
26 | #[get("/string_state")]
27 | fn string_state(state: &State) -> CustomResponder {
28 | CustomResponder { responder: "".to_string(), state: &*state }
29 | }
30 |
--------------------------------------------------------------------------------
/contrib/sync_db_pools/lib/src/error.rs:
--------------------------------------------------------------------------------
1 | use rocket::figment;
2 |
3 | /// A wrapper around `r2d2::Error`s or a custom database error type.
4 | ///
5 | /// This type is only relevant to implementors of the [`Poolable`] trait. See
6 | /// the [`Poolable`] documentation for more information on how to use this type.
7 | ///
8 | /// [`Poolable`]: crate::Poolable
9 | #[derive(Debug)]
10 | pub enum Error {
11 | /// A custom error of type `T`.
12 | Custom(T),
13 | /// An error occurred while initializing an `r2d2` pool.
14 | Pool(r2d2::Error),
15 | /// An error occurred while extracting a `figment` configuration.
16 | Config(figment::Error),
17 | }
18 |
19 | impl From for Error {
20 | fn from(error: figment::Error) -> Self {
21 | Error::Config(error)
22 | }
23 | }
24 |
25 | impl From for Error {
26 | fn from(error: r2d2::Error) -> Self {
27 | Error::Pool(error)
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/core/lib/src/mtls.rs:
--------------------------------------------------------------------------------
1 | //! Support for mutual TLS client certificates.
2 | //!
3 | //! For details on how to configure mutual TLS, see
4 | //! [`MutualTls`](crate::config::MutualTls) and the [TLS
5 | //! guide](https://rocket.rs/v0.5-rc/guide/configuration/#tls). See
6 | //! [`Certificate`] for a request guard that validated, verifies, and retrieves
7 | //! client certificates.
8 |
9 | #[doc(inline)]
10 | pub use crate::http::tls::mtls::*;
11 |
12 | use crate::request::{Request, FromRequest, Outcome};
13 | use crate::outcome::{try_outcome, IntoOutcome};
14 | use crate::http::Status;
15 |
16 | #[crate::async_trait]
17 | impl<'r> FromRequest<'r> for Certificate<'r> {
18 | type Error = Error;
19 |
20 | async fn from_request(req: &'r Request<'_>) -> Outcome {
21 | let certs = try_outcome!(req.connection.client_certificates.as_ref().or_forward(()));
22 | Certificate::parse(certs).into_outcome(Status::Unauthorized)
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/contrib/db_pools/codegen/tests/ui-fail-nightly/database-types.stderr:
--------------------------------------------------------------------------------
1 | error[E0277]: the trait bound `Unknown: Pool` is not satisfied
2 | --> $DIR/database-types.rs:7:10
3 | |
4 | 7 | struct A(Unknown);
5 | | ^^^^^^^ the trait `Pool` is not implemented for `Unknown`
6 | |
7 | note: required by a bound in `rocket_db_pools::Database::Pool`
8 | --> $DIR/database.rs:41:16
9 | |
10 | 41 | type Pool: Pool;
11 | | ^^^^ required by this bound in `rocket_db_pools::Database::Pool`
12 |
13 | error[E0277]: the trait bound `Vec: Pool` is not satisfied
14 | --> $DIR/database-types.rs:11:10
15 | |
16 | 11 | struct B(Vec);
17 | | ^^^^^^^^ the trait `Pool` is not implemented for `Vec`
18 | |
19 | note: required by a bound in `rocket_db_pools::Database::Pool`
20 | --> $DIR/database.rs:41:16
21 | |
22 | 41 | type Pool: Pool;
23 | | ^^^^ required by this bound in `rocket_db_pools::Database::Pool`
24 |
--------------------------------------------------------------------------------
/core/lib/tests/absolute-uris-okay-issue-443.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | use rocket::response::Redirect;
4 |
5 | #[get("/http")]
6 | fn http() -> Redirect {
7 | Redirect::to(uri!("http://rocket.rs"))
8 | }
9 |
10 | #[get("/rocket")]
11 | fn redirect() -> Redirect {
12 | Redirect::to("https://rocket.rs:80")
13 | }
14 |
15 | mod test_absolute_uris_okay {
16 | use super::*;
17 | use rocket::local::blocking::Client;
18 |
19 | #[test]
20 | fn redirect_works() {
21 | let client = Client::debug_with(routes![http, redirect]).unwrap();
22 |
23 | let response = client.get(uri!(http)).dispatch();
24 | let location = response.headers().get_one("Location");
25 | assert_eq!(location, Some("http://rocket.rs"));
26 |
27 | let response = client.get(uri!(redirect)).dispatch();
28 | let location = response.headers().get_one("Location");
29 | assert_eq!(location, Some("https://rocket.rs:80"));
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/contrib/sync_db_pools/codegen/tests/ui-fail-stable/database-types.stderr:
--------------------------------------------------------------------------------
1 | error[E0277]: the trait bound `Unknown: Poolable` is not satisfied
2 | --> $DIR/database-types.rs:6:10
3 | |
4 | 6 | struct A(Unknown);
5 | | ^^^^^^^ the trait `Poolable` is not implemented for `Unknown`
6 | |
7 | ::: $WORKSPACE/contrib/sync_db_pools/lib/src/connection.rs
8 | |
9 | | pub struct Connection {
10 | | -------- required by this bound in `rocket_sync_db_pools::Connection`
11 |
12 | error[E0277]: the trait bound `Vec: Poolable` is not satisfied
13 | --> $DIR/database-types.rs:9:10
14 | |
15 | 9 | struct B(Vec);
16 | | ^^^ the trait `Poolable` is not implemented for `Vec`
17 | |
18 | ::: $WORKSPACE/contrib/sync_db_pools/lib/src/connection.rs
19 | |
20 | | pub struct Connection {
21 | | -------- required by this bound in `rocket_sync_db_pools::Connection`
22 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug-report.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Bug Report
3 | about: Report behavior that deviates from specification or expectation
4 | title: ''
5 | labels: triage
6 | assignees: ''
7 | ---
8 |
9 | **Description**
10 |
11 | A clear and concise description of what the bug is. This should include links to documentation that is contradicted or an explanation of why the present functionality doesn't match your expectation.
12 |
13 | **To Reproduce**
14 |
15 | How to reproduce the bug. A fully working code example (`main.rs` + `Cargo.toml`) is preferred.
16 |
17 | **Expected Behavior**
18 |
19 | A clear and concise description of what you expected to happen.
20 |
21 | **Environment:**
22 |
23 | - OS Distribution and Kernel: [e.g. Arch Linux 4.16.13, macOS 11.2.1]
24 | - Rocket Version: [e.g. 0.4.12, master@abf996b]
25 |
26 | **Additional Context**
27 |
28 | Add any other context about the problem here, for example, how you uncovered the bug or if you have ideas about what/where Rocket is going wrong.
29 |
--------------------------------------------------------------------------------
/core/codegen/src/attribute/param/guard.rs:
--------------------------------------------------------------------------------
1 | use std::hash::{Hash, Hasher};
2 |
3 | use devise::{FromMeta, MetaItem, Result};
4 | use proc_macro2::Span;
5 |
6 | use crate::name::Name;
7 | use crate::proc_macro_ext::StringLit;
8 | use crate::http::uri;
9 |
10 | impl Dynamic {
11 | pub fn is_wild(&self) -> bool {
12 | self.value == "_"
13 | }
14 | }
15 |
16 | impl FromMeta for Dynamic {
17 | fn from_meta(meta: &MetaItem) -> Result {
18 | let string = StringLit::from_meta(meta)?;
19 | let span = string.subspan(1..string.len() + 1);
20 |
21 | // We don't allow `_`. We abuse `fmt::Query` to enforce this.
22 | Ok(Dynamic::parse::(&string, span)?)
23 | }
24 | }
25 |
26 | impl PartialEq for Dynamic {
27 | fn eq(&self, other: &Dynamic) -> bool {
28 | self.value == other.value
29 | }
30 | }
31 |
32 | impl Eq for Dynamic {}
33 |
34 | impl Hash for Dynamic {
35 | fn hash(&self, state: &mut H) {
36 | self.value.hash(state)
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/core/codegen/src/attribute/entry/main.rs:
--------------------------------------------------------------------------------
1 | use super::EntryAttr;
2 |
3 | use devise::{Spanned, Result};
4 | use devise::ext::SpanDiagnosticExt;
5 | use proc_macro2::{TokenStream, Span};
6 |
7 | /// `#[rocket::async_main]`: calls the attributed fn inside `rocket::async_main`
8 | pub struct Main;
9 |
10 | impl EntryAttr for Main {
11 | const REQUIRES_ASYNC: bool = true;
12 |
13 | fn function(f: &mut syn::ItemFn) -> Result {
14 | let (attrs, vis, block, sig) = (&f.attrs, &f.vis, &f.block, &mut f.sig);
15 | if sig.ident != "main" {
16 | // FIXME(diag): warning!
17 | Span::call_site()
18 | .warning("attribute is typically applied to `main` function")
19 | .span_note(sig.ident.span(), "this function is not `main`")
20 | .emit_as_item_tokens();
21 | }
22 |
23 | sig.asyncness = None;
24 | Ok(quote_spanned!(block.span() => #(#attrs)* #vis #sig {
25 | ::rocket::async_main(async move #block)
26 | }))
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/scripts/mk-docs.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | set -e
3 |
4 | #
5 | # Builds the rustdocs for all of the libraries.
6 | #
7 |
8 | # Brings in: PROJECT_ROOT, EXAMPLES_DIR, LIB_DIR, CODEGEN_DIR, CONTRIB_DIR, DOC_DIR
9 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
10 | source "${SCRIPT_DIR}/config.sh"
11 |
12 | if [ "${1}" != "-d" ]; then
13 | # We need to clean-up beforehand so we don't get all of the dependencies.
14 | echo ":::: Cleaning up before documenting..."
15 | cargo clean
16 | cargo update
17 | fi
18 |
19 | # Generate the rustdocs for all of the crates.
20 | echo ":::: Generating the docs..."
21 | pushd "${PROJECT_ROOT}" > /dev/null 2>&1
22 | # Set the crate version and fill in missing doc URLs with docs.rs links.
23 | RUSTDOCFLAGS="-Zunstable-options --crate-version ${DOC_VERSION}" \
24 | cargo doc -p rocket \
25 | -p rocket_sync_db_pools -p rocket_dyn_templates -p rocket_db_pools \
26 | -Zrustdoc-map --no-deps --all-features
27 | popd > /dev/null 2>&1
28 |
29 | # Blank index, for redirection.
30 | touch "${DOC_DIR}/index.html"
31 |
--------------------------------------------------------------------------------
/contrib/sync_db_pools/codegen/tests/ui-fail-nightly/database-types.stderr:
--------------------------------------------------------------------------------
1 | error[E0277]: the trait bound `Unknown: Poolable` is not satisfied
2 | --> $DIR/database-types.rs:6:10
3 | |
4 | 6 | struct A(Unknown);
5 | | ^^^^^^^ the trait `Poolable` is not implemented for `Unknown`
6 | |
7 | note: required by a bound in `rocket_sync_db_pools::Connection`
8 | --> $DIR/connection.rs:44:29
9 | |
10 | 44 | pub struct Connection {
11 | | ^^^^^^^^ required by this bound in `rocket_sync_db_pools::Connection`
12 |
13 | error[E0277]: the trait bound `Vec: Poolable` is not satisfied
14 | --> $DIR/database-types.rs:9:10
15 | |
16 | 9 | struct B(Vec);
17 | | ^^^^^^^^ the trait `Poolable` is not implemented for `Vec`
18 | |
19 | note: required by a bound in `rocket_sync_db_pools::Connection`
20 | --> $DIR/connection.rs:44:29
21 | |
22 | 44 | pub struct Connection {
23 | | ^^^^^^^^ required by this bound in `rocket_sync_db_pools::Connection`
24 |
--------------------------------------------------------------------------------
/core/lib/build.rs:
--------------------------------------------------------------------------------
1 | //! Ensures Rocket isn't compiled with an incompatible version of Rust.
2 |
3 | use yansi::{Paint, Color::{Red, Yellow}};
4 |
5 | fn main() {
6 | const MIN_VERSION: &str = "1.46.0";
7 |
8 | if let Some(version) = version_check::Version::read() {
9 | if !version.at_least(MIN_VERSION) {
10 | let msg = "Rocket requires a more recent version of rustc.";
11 | eprintln!("{} {}", Red.paint("Error:").bold(), Paint::new(msg).bold());
12 | eprintln!("Installed version: {}", Yellow.paint(version));
13 | eprintln!("Minimum required: {}", Yellow.paint(MIN_VERSION));
14 | panic!("Aborting compilation due to incompatible compiler.")
15 | }
16 | } else {
17 | println!("cargo:warning=Rocket was unable to check rustc compiler compatibility.");
18 | println!("cargo:warning=Build may fail due to incompatible rustc version.");
19 | }
20 |
21 | if let Some(true) = version_check::is_feature_flaggable() {
22 | println!("cargo:rustc-cfg=nightly");
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/examples/tls/Rocket.toml:
--------------------------------------------------------------------------------
1 | # The certificate key pairs used here were generated with openssl via the
2 | # 'private/gen_certs.sh' script.
3 | #
4 | # These certificates are self-signed. As such, you will need to trust them
5 | # directly for your browser to show connections as secure. You should NEVER use
6 | # these certificate/key pairs. They are here for DEMONSTRATION PURPOSES ONLY.
7 |
8 | [default.tls]
9 | certs = "private/rsa_sha256_cert.pem"
10 | key = "private/rsa_sha256_key.pem"
11 |
12 | [default.tls.mutual]
13 | ca_certs = "private/ca_cert.pem"
14 | mandatory = false
15 |
16 | [rsa_sha256.tls]
17 | certs = "private/rsa_sha256_cert.pem"
18 | key = "private/rsa_sha256_key.pem"
19 |
20 | [ecdsa_nistp256_sha256.tls]
21 | certs = "private/ecdsa_nistp256_sha256_cert.pem"
22 | key = "private/ecdsa_nistp256_sha256_key_pkcs8.pem"
23 |
24 | [ecdsa_nistp384_sha384.tls]
25 | certs = "private/ecdsa_nistp384_sha384_cert.pem"
26 | key = "private/ecdsa_nistp384_sha384_key_pkcs8.pem"
27 |
28 | [ed25519.tls]
29 | certs = "private/ed25519_cert.pem"
30 | key = "private/ed25519_key.pem"
31 |
--------------------------------------------------------------------------------
/core/http/src/uri/error.rs:
--------------------------------------------------------------------------------
1 | //! Errors arising from parsing invalid URIs.
2 |
3 | use std::fmt;
4 |
5 | pub use crate::parse::uri::Error;
6 |
7 | /// The error type returned when a URI conversion fails.
8 | #[derive(Debug, Copy, Clone, PartialEq, Eq)]
9 | pub struct TryFromUriError(pub(crate) ());
10 |
11 | impl fmt::Display for TryFromUriError {
12 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13 | "invalid conversion from general to specific URI variant".fmt(f)
14 | }
15 | }
16 |
17 | /// An error interpreting a segment as a [`PathBuf`] component in
18 | /// [`Segments::to_path_buf()`].
19 | ///
20 | /// [`PathBuf`]: std::path::PathBuf
21 | /// [`Segments::to_path_buf()`]: crate::uri::Segments::to_path_buf()
22 | #[derive(Debug, PartialEq, Eq, Clone)]
23 | pub enum PathError {
24 | /// The segment started with the wrapped invalid character.
25 | BadStart(char),
26 | /// The segment contained the wrapped invalid character.
27 | BadChar(char),
28 | /// The segment ended with the wrapped invalid character.
29 | BadEnd(char),
30 | }
31 |
--------------------------------------------------------------------------------
/benchmarks/static/rust-lang.routes:
--------------------------------------------------------------------------------
1 | GET / (index)
2 | GET / (category)
3 | GET /governance (governance)
4 | GET /governance// [2] (team)
5 | GET /production/users (production)
6 | GET /sponsors (sponsors)
7 | GET // [4] (subject)
8 | GET /static/ (files)
9 | GET /robots.txt (robots_txt)
10 | GET /logos/ (logos)
11 | GET /components/<_file..> (components)
12 | GET / [3] (index_locale)
13 | GET // [11] (category_locale)
14 | GET //governance [10] (governance_locale)
15 | GET //governance// [12] (team_locale)
16 | GET //production/users [10] (production_locale)
17 | GET //sponsors [10] (sponsors_locale)
18 | GET /// [14] (subject_locale)
19 | GET //components/<_file..> [12] (components_locale)
20 | GET / [19] (redirect)
21 | GET /pdfs/ (redirect_pdfs)
22 | GET /en-US (redirect_bare_en_us)
23 | GET /<_locale> [20] (redirect_bare_locale)
24 | GET /en-US/ (redirect_en_us)
25 | GET /<_locale>/ [20] (redirect_locale)
26 |
--------------------------------------------------------------------------------
/core/lib/tests/route_guard.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | use std::path::{Path, PathBuf};
4 | use rocket::http::ext::Normalize;
5 | use rocket::Route;
6 |
7 | #[get("/")]
8 | fn files(route: &Route, path: PathBuf) -> String {
9 | Path::new(route.uri.base()).join(path).normalized_str().to_string()
10 | }
11 |
12 | mod route_guard_tests {
13 | use super::*;
14 | use rocket::local::blocking::Client;
15 |
16 | fn assert_path(client: &Client, path: &str) {
17 | let res = client.get(path).dispatch();
18 | assert_eq!(res.into_string(), Some(path.into()));
19 | }
20 |
21 | #[test]
22 | fn check_mount_path() {
23 | let rocket = rocket::build()
24 | .mount("/first", routes![files])
25 | .mount("/second", routes![files]);
26 |
27 | let client = Client::debug(rocket).unwrap();
28 | assert_path(&client, "/first/some/path");
29 | assert_path(&client, "/second/some/path");
30 | assert_path(&client, "/first/second/b/c");
31 | assert_path(&client, "/second/a/b/c");
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/contrib/dyn_templates/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "rocket_dyn_templates"
3 | version = "0.1.0-rc.1"
4 | authors = ["Sergio Benitez "]
5 | description = "Dynamic templating engine integration for Rocket."
6 | documentation = "https://api.rocket.rs/v0.5-rc/rocket_dyn_templates/"
7 | homepage = "https://rocket.rs"
8 | repository = "https://github.com/SergioBenitez/Rocket/tree/master/contrib/dyn_templates"
9 | readme = "README.md"
10 | keywords = ["rocket", "framework", "templates", "templating", "engine"]
11 | license = "MIT OR Apache-2.0"
12 | edition = "2018"
13 |
14 | [features]
15 | tera = ["tera_"]
16 | handlebars = ["handlebars_"]
17 |
18 | [dependencies]
19 | glob = "0.3"
20 | notify = "4.0.6"
21 | normpath = "0.3"
22 |
23 | [dependencies.rocket]
24 | version = "0.5.0-rc.1"
25 | path = "../../core/lib"
26 | default-features = false
27 |
28 | [dependencies.tera_]
29 | package = "tera"
30 | version = "1.10.0"
31 | optional = true
32 |
33 | [dependencies.handlebars_]
34 | package = "handlebars"
35 | version = "4.1"
36 | optional = true
37 |
38 | [package.metadata.docs.rs]
39 | all-features = true
40 |
--------------------------------------------------------------------------------
/core/codegen/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "rocket_codegen"
3 | version = "0.5.0-rc.1"
4 | authors = ["Sergio Benitez "]
5 | description = "Procedural macros for the Rocket web framework."
6 | documentation = "https://api.rocket.rs/v0.5-rc/rocket_codegen/"
7 | homepage = "https://rocket.rs"
8 | repository = "https://github.com/SergioBenitez/Rocket"
9 | readme = "../../README.md"
10 | keywords = ["rocket", "web", "framework", "code", "generation"]
11 | license = "MIT OR Apache-2.0"
12 | edition = "2018"
13 |
14 | [lib]
15 | proc-macro = true
16 |
17 | [dependencies]
18 | indexmap = "1.0"
19 | quote = "1.0"
20 | syn = { version = "1.0.72", features = ["full", "visit", "visit-mut", "extra-traits"] }
21 | proc-macro2 = "1.0.27"
22 | devise = "0.3.1"
23 | rocket_http = { version = "0.5.0-rc.1", path = "../http/" }
24 | unicode-xid = "0.2"
25 | glob = "0.3"
26 |
27 | [dev-dependencies]
28 | rocket = { version = "0.5.0-rc.1", path = "../lib", features = ["json", "msgpack"] }
29 | time = { version = "0.3", features = ["macros"] }
30 | pretty_assertions = "0.7"
31 | version_check = "0.9"
32 | trybuild = "1.0"
33 |
--------------------------------------------------------------------------------
/core/lib/tests/form_value_from_encoded_str-issue-1425.rs:
--------------------------------------------------------------------------------
1 | use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
2 |
3 | use rocket::http::RawStr;
4 | use rocket::form::Form;
5 |
6 | macro_rules! assert_from_form_field_eq {
7 | ($string:literal as $T:ty, $expected:expr) => (
8 | let value_str = RawStr::new(concat!("=", $string));
9 | let value = Form::<$T>::parse_encoded(value_str).unwrap();
10 | assert_eq!(value, $expected);
11 | )
12 | }
13 |
14 | #[test]
15 | fn test_from_form_value_encoded() {
16 | assert_from_form_field_eq!(
17 | "127.0.0.1%3A80" as SocketAddrV4,
18 | SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 80)
19 | );
20 |
21 | assert_from_form_field_eq!(
22 | "2001%3A0db8%3A85a3%3A0000%3A0000%3A8a2e%3A0370%3A7334" as Ipv6Addr,
23 | Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0x8a2e, 0x0370, 0x7334)
24 | );
25 |
26 | assert_from_form_field_eq!(
27 | "%5B2001%3Adb8%3A%3A1%5D%3A8080" as SocketAddrV6,
28 | SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0)
29 | );
30 | }
31 |
--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | Copyright (c) 2016 Sergio Benitez
3 |
4 | Permission is hereby granted, free of charge, to any person obtaining a copy of
5 | this software and associated documentation files (the "Software"), to deal in
6 | the Software without restriction, including without limitation the rights to
7 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
8 | the Software, and to permit persons to whom the Software is furnished to do so,
9 | subject to the following conditions:
10 |
11 | The above copyright notice and this permission notice shall be included in all
12 | copies or substantial portions of the Software.
13 |
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
16 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
17 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
18 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 |
--------------------------------------------------------------------------------
/examples/serialization/src/uuid.rs:
--------------------------------------------------------------------------------
1 | use std::collections::HashMap;
2 |
3 | use rocket::State;
4 | use rocket::serde::uuid::Uuid;
5 |
6 | // A small people mapping in managed state for the sake of this example. In a
7 | // real application this would be a database.
8 | struct People(HashMap);
9 |
10 | #[get("/people/")]
11 | fn people(id: Uuid, people: &State) -> Result {
12 | people.0.get(&id)
13 | .map(|person| format!("We found: {}", person))
14 | .ok_or_else(|| format!("Missing person for UUID: {}", id))
15 | }
16 |
17 | pub fn stage() -> rocket::fairing::AdHoc {
18 | // Seed the "database".
19 | let mut map = HashMap::new();
20 | map.insert("7f205202-7ba1-4c39-b2fc-3e630722bf9f".parse().unwrap(), "Lacy");
21 | map.insert("4da34121-bc7d-4fc1-aee6-bf8de0795333".parse().unwrap(), "Bob");
22 | map.insert("ad962969-4e3d-4de7-ac4a-2d86d6d10839".parse().unwrap(), "George");
23 |
24 | rocket::fairing::AdHoc::on_ignite("UUID", |rocket| async {
25 | rocket
26 | .manage(People(map))
27 | .mount("/", routes![people])
28 | })
29 | }
30 |
--------------------------------------------------------------------------------
/core/lib/tests/scoped-uri.rs:
--------------------------------------------------------------------------------
1 | use rocket::{Rocket, Build};
2 | use rocket::local::blocking::Client;
3 |
4 | mod inner {
5 | use rocket::uri;
6 |
7 | #[rocket::get("/")]
8 | pub fn hello() -> String {
9 | format!("Hello! Try {}.", uri!(super::hello_name("Rust 2018")))
10 | }
11 | }
12 |
13 | #[rocket::get("/")]
14 | fn hello_name(name: String) -> String {
15 | format!("Hello, {}! This is {}.", name, rocket::uri!(hello_name(&name)))
16 | }
17 |
18 | fn rocket() -> Rocket {
19 | rocket::build()
20 | .mount("/", rocket::routes![hello_name])
21 | .mount("/", rocket::routes![inner::hello])
22 | }
23 |
24 | #[test]
25 | fn test_inner_hello() {
26 | let client = Client::debug(rocket()).unwrap();
27 | let response = client.get("/").dispatch();
28 | assert_eq!(response.into_string(), Some("Hello! Try /Rust%202018.".into()));
29 | }
30 |
31 | #[test]
32 | fn test_hello_name() {
33 | let client = Client::debug(rocket()).unwrap();
34 | let response = client.get("/Rust%202018").dispatch();
35 | assert_eq!(response.into_string().unwrap(), "Hello, Rust 2018! This is /Rust%202018.");
36 | }
37 |
--------------------------------------------------------------------------------
/site/guide/1-quickstart.md:
--------------------------------------------------------------------------------
1 | # Quickstart
2 |
3 | Before you can start writing a Rocket application, you'll need to install the
4 | Rust toolchain. We recommend using [rustup](https://rustup.rs/). If you don't
5 | have Rust installed and would like extra guidance doing so, see the [getting
6 | started](../getting-started) section.
7 |
8 | ## Running Examples
9 |
10 | The absolute fastest way to start experimenting with Rocket is to clone the
11 | Rocket repository and run the included examples in the `examples/` directory.
12 | For instance, the following set of commands runs the `hello` example:
13 |
14 | ```sh
15 | git clone https://github.com/SergioBenitez/Rocket
16 | cd Rocket
17 | git checkout v0.5-rc
18 | cd examples/hello
19 | cargo run
20 | ```
21 |
22 | There are numerous examples in the `examples/` directory. They can all be run
23 | with `cargo run`.
24 |
25 | ! note
26 |
27 | The examples' `Cargo.toml` files will point to the locally cloned `rocket`
28 | libraries. When copying the examples for your own use, you should modify the
29 | `Cargo.toml` files as explained in the [Getting Started] guide.
30 |
31 | [Getting Started]: ../getting-started
32 |
--------------------------------------------------------------------------------
/examples/todo/static/css/style.css:
--------------------------------------------------------------------------------
1 | .field-error {
2 | border: 1px solid #ff0000 !important;
3 | }
4 |
5 | .field-error-msg {
6 | color: #ff0000;
7 | display: block;
8 | margin: -10px 0 10px 0;
9 | }
10 |
11 | .field-success {
12 | border: 1px solid #5AB953 !important;
13 | }
14 |
15 | .field-success-msg {
16 | color: #5AB953;
17 | display: block;
18 | margin: -10px 0 10px 0;
19 | }
20 |
21 | span.completed {
22 | text-decoration: line-through;
23 | }
24 |
25 | form.inline {
26 | display: inline;
27 | }
28 |
29 | form.link,
30 | button.link {
31 | display: inline;
32 | color: #1EAEDB;
33 | border: none;
34 | outline: none;
35 | background: none;
36 | cursor: pointer;
37 | padding: 0;
38 | margin: 0 0 0 0;
39 | height: inherit;
40 | text-decoration: underline;
41 | font-size: inherit;
42 | text-transform: none;
43 | font-weight: normal;
44 | line-height: inherit;
45 | letter-spacing: inherit;
46 | }
47 |
48 | form.link:hover, button.link:hover {
49 | color: #0FA0CE;
50 | }
51 |
52 | button.small {
53 | height: 20px;
54 | padding: 0 10px;
55 | font-size: 10px;
56 | line-height: 20px;
57 | margin: 0 2.5px;
58 | }
59 |
--------------------------------------------------------------------------------
/core/lib/tests/form_value_decoding-issue-82.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | use rocket::form::Form;
4 |
5 | #[post("/", data = "")]
6 | fn bug(form_data: Form) -> String {
7 | form_data.into_inner()
8 | }
9 |
10 | mod tests {
11 | use super::*;
12 | use rocket::local::blocking::Client;
13 | use rocket::http::ContentType;
14 | use rocket::http::Status;
15 |
16 | fn check_decoding(raw: &str, decoded: &str) {
17 | let client = Client::debug_with(routes![bug]).unwrap();
18 | let response = client.post("/")
19 | .header(ContentType::Form)
20 | .body(format!("form_data={}", raw))
21 | .dispatch();
22 |
23 | assert_eq!(response.status(), Status::Ok);
24 | assert_eq!(Some(decoded.to_string()), response.into_string());
25 | }
26 |
27 | #[test]
28 | fn test_proper_decoding() {
29 | check_decoding("password", "password");
30 | check_decoding("", "");
31 | check_decoding("+", " ");
32 | check_decoding("%2B", "+");
33 | check_decoding("1+1", "1 1");
34 | check_decoding("1%2B1", "1+1");
35 | check_decoding("%3Fa%3D1%26b%3D2", "?a=1&b=2");
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/examples/templating/src/tera.rs:
--------------------------------------------------------------------------------
1 | use rocket::Request;
2 | use rocket::response::Redirect;
3 |
4 | use rocket_dyn_templates::{Template, tera::Tera, context};
5 |
6 | #[get("/")]
7 | pub fn index() -> Redirect {
8 | Redirect::to(uri!("/tera", hello(name = "Your Name")))
9 | }
10 |
11 | #[get("/hello/")]
12 | pub fn hello(name: &str) -> Template {
13 | Template::render("tera/index", context! {
14 | title: "Hello",
15 | name: Some(name),
16 | items: vec!["One", "Two", "Three"],
17 | })
18 | }
19 |
20 | #[get("/about")]
21 | pub fn about() -> Template {
22 | Template::render("tera/about.html", context! {
23 | title: "About",
24 | })
25 | }
26 |
27 | #[catch(404)]
28 | pub fn not_found(req: &Request<'_>) -> Template {
29 | Template::render("tera/error/404", context! {
30 | uri: req.uri()
31 | })
32 | }
33 |
34 | pub fn customize(tera: &mut Tera) {
35 | tera.add_raw_template("tera/about.html", r#"
36 | {% extends "tera/base" %}
37 |
38 | {% block content %}
39 |
40 | About - Here's another page!
41 |
42 | {% endblock content %}
43 | "#).expect("valid Tera template");
44 | }
45 |
--------------------------------------------------------------------------------
/core/lib/tests/unsound-local-request-1312.rs:
--------------------------------------------------------------------------------
1 | use rocket::http::Header;
2 | use rocket::local::blocking::Client;
3 |
4 | #[test]
5 | fn test_local_request_clone_soundness() {
6 | let client = Client::debug_with(vec![]).unwrap();
7 |
8 | // creates two LocalRequest instances that shouldn't share the same req
9 | let r1 = client.get("/").header(Header::new("key", "val1"));
10 | let mut r2 = r1.clone();
11 |
12 | // save the iterator, which internally holds a slice
13 | let mut iter = r1.inner().headers().get("key");
14 |
15 | // insert headers to force header map reallocation.
16 | for i in 0..100 {
17 | r2.add_header(Header::new(i.to_string(), i.to_string()));
18 | }
19 |
20 | // Replace the original key/val.
21 | r2.add_header(Header::new("key", "val2"));
22 |
23 | // Heap massage: so we've got crud to print.
24 | let _: Vec = vec![0, 0xcafebabe, 31337, 0];
25 |
26 | // Ensure we're good.
27 | let s = iter.next().unwrap();
28 | println!("{}", s);
29 |
30 | // And that we've got the right data.
31 | assert_eq!(r1.inner().headers().get("key").collect::>(), vec!["val1"]);
32 | assert_eq!(r2.inner().headers().get("key").collect::>(), vec!["val1", "val2"]);
33 | }
34 |
--------------------------------------------------------------------------------
/examples/tls/private/ed25519_cert.pem:
--------------------------------------------------------------------------------
1 | -----BEGIN CERTIFICATE-----
2 | MIIDMjCCARqgAwIBAgIUdMGHQoLHGcks+Hnw7dC5dEl0/ogwDQYJKoZIhvcNAQEL
3 | BQAwRzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRIwEAYDVQQKDAlSb2NrZXQg
4 | Q0ExFzAVBgNVBAMMDlJvY2tldCBSb290IENBMB4XDTIxMDcwOTIzMzMzM1oXDTMx
5 | MDcwNzIzMzMzM1owPzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQ8wDQYDVQQK
6 | DAZSb2NrZXQxEjAQBgNVBAMMCWxvY2FsaG9zdDAqMAUGAytlcAMhAP7ORUynwg2q
7 | IbwJwpOThFhc/IhiWxIIACcaiNKPtdEzoxgwFjAUBgNVHREEDTALgglsb2NhbGhv
8 | c3QwDQYJKoZIhvcNAQELBQADggIBAKcrsLA9ijRjE/h8FUNbEz547a8wCy6NskRh
9 | vCLIsC3k3pfhmKatM3BSwrpePFv6iSPIlp6rY9rTYx+vnLGVnT5bjPDA3Q5VwyIF
10 | lAYnbZP7VSQKWr2hLqFd/3sUvg7kSL16nVi4GaRYTAH2W9IQWyx+GKqv6lRmDFwS
11 | TCoPu2YnoboWTYMFdsrxdkzvBkQX+IF45aVTnUbAcLAc7hgZdK6+ZAhIk4ymDDWj
12 | FeGi/hJ5zF9a/zdV+62CHuIwgCT3ETUXeVLKWf6+v2pOMYXmpdPJf5g06zsrpcYY
13 | i+ZdYPXFs4/yzwcUpgYdkpszMJcxgUSn/u2E9/9BFtJa/kwDbHCDItyR2rSeDoUI
14 | 2mQY6Kjm8BucM8hBoNYh9HOHEn1450PHIyWzcSMFkhfqSAKzngVcuSmRkUYhIdHu
15 | bUu29CLJzvOCTFxAWd4uWO2EbH5QFOeD9sQjqzadw0KX5kZl3Oe0wJqLswpKXd7m
16 | uQzcIjGNhY3STk722z0sFuZOvZPoi2d46ZKRBIJ9OYQfUzLDWW1PjqIuX7gWOUfe
17 | PaSs8K2qQlfniPJzHFQ3XHB4KJoWP2BcTUh5mkmpq5st5Buox8JUeAH+SalltR+K
18 | Skvvyv6hIhKyUDrgqV3dhIdTiexRLsmosXdps7ifJdmDtJcuWVp5hCS05X5oHTk/
19 | 6WWSkctl
20 | -----END CERTIFICATE-----
21 |
--------------------------------------------------------------------------------
/core/lib/tests/form_method-issue-45.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | use rocket::form::Form;
4 |
5 | #[derive(FromForm)]
6 | struct FormData {
7 | form_data: String,
8 | }
9 |
10 | #[patch("/", data = "")]
11 | fn bug(form_data: Form) -> &'static str {
12 | assert_eq!("Form data", form_data.into_inner().form_data);
13 | "OK"
14 | }
15 |
16 | mod tests {
17 | use super::*;
18 | use rocket::local::blocking::Client;
19 | use rocket::http::{Status, ContentType};
20 |
21 | #[test]
22 | fn method_eval() {
23 | let client = Client::debug_with(routes![bug]).unwrap();
24 | let response = client.post("/")
25 | .header(ContentType::Form)
26 | .body("_method=patch&form_data=Form+data")
27 | .dispatch();
28 |
29 | assert_eq!(response.into_string(), Some("OK".into()));
30 | }
31 |
32 | #[test]
33 | fn get_passes_through() {
34 | let client = Client::debug_with(routes![bug]).unwrap();
35 | let response = client.get("/")
36 | .header(ContentType::Form)
37 | .body("_method=patch&form_data=Form+data")
38 | .dispatch();
39 |
40 | assert_eq!(response.status(), Status::NotFound);
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature-request.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Feature Request
3 | about: Propose a change that introduces new functionality
4 | title: ''
5 | labels: request
6 | assignees: ''
7 | ---
8 |
9 | **Is your feature request motivated by a concrete problem? Please describe.**
10 |
11 | A clear and concise description of what the problem is. Examples:
12 |
13 | - "I frequently want to do X, but Rocket makes it hard. It would be nice if Rocket..."
14 | - "I want to do X but Rocket makes it impossible because..."
15 | - "Feature Z exists, but it has these drawbacks. What if..."
16 |
17 | **Why this feature can't or shouldn't live outside of Rocket**
18 |
19 | Rocket is designed to have a small but pluggable core. Feature requests that can be implemented outside of Rocket are typically declined. Make a case for why this feature can't or shouldn't be implemented outside of Rocket.
20 |
21 | **Ideal Solution**
22 |
23 | If you have an idea for a solution, propose it with a clear and concise description.
24 |
25 | **Alternatives Considered**
26 |
27 | A clear and concise description of any alternative solutions or features you've considered.
28 |
29 | **Additional Context**
30 |
31 | Add any other context here, for example, descriptions of elegant solutions in other software.
32 |
--------------------------------------------------------------------------------
/contrib/dyn_templates/src/handlebars_templates.rs:
--------------------------------------------------------------------------------
1 | use std::path::Path;
2 |
3 | use rocket::serde::Serialize;
4 |
5 | use crate::engine::Engine;
6 | pub use crate::handlebars::Handlebars;
7 |
8 | impl Engine for Handlebars<'static> {
9 | const EXT: &'static str = "hbs";
10 |
11 | fn init<'a>(templates: impl Iterator- ) -> Option {
12 | let mut hb = Handlebars::new();
13 | let mut ok = true;
14 | for (name, path) in templates {
15 | if let Err(e) = hb.register_template_file(name, path) {
16 | error!("Handlebars template '{}' failed to register.", name);
17 | error_!("{}", e);
18 | info_!("Template path: '{}'.", path.to_string_lossy());
19 | ok = false;
20 | }
21 | }
22 |
23 | ok.then(|| hb)
24 | }
25 |
26 | fn render(&self, name: &str, context: C) -> Option {
27 | if self.get_template(name).is_none() {
28 | error_!("Handlebars template '{}' does not exist.", name);
29 | return None;
30 | }
31 |
32 | Handlebars::render(self, name, &context)
33 | .map_err(|e| error_!("Handlebars: {}", e))
34 | .ok()
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/examples/fairings/src/tests.rs:
--------------------------------------------------------------------------------
1 | use super::rocket;
2 | use rocket::local::blocking::Client;
3 |
4 | #[test]
5 | fn rewrite_get_put() {
6 | let client = Client::tracked(rocket()).unwrap();
7 | let response = client.get("/").dispatch();
8 | assert_eq!(response.into_string(), Some("Hello, fairings!".into()));
9 | }
10 |
11 | #[test]
12 | fn counts() {
13 | let client = Client::tracked(rocket()).unwrap();
14 |
15 | // Issue 1 GET request.
16 | client.get("/").dispatch();
17 |
18 | // Check the GET count, taking into account _this_ GET request.
19 | let response = client.get("/counts").dispatch();
20 | assert_eq!(response.into_string(), Some("Get: 2\nPost: 0".into()));
21 |
22 | // Issue 1 more GET request and a POST.
23 | client.get("/").dispatch();
24 | client.post("/").dispatch();
25 |
26 | // Check the counts.
27 | let response = client.get("/counts").dispatch();
28 | assert_eq!(response.into_string(), Some("Get: 4\nPost: 1".into()));
29 | }
30 |
31 | #[test]
32 | fn token() {
33 | let client = Client::tracked(rocket()).unwrap();
34 |
35 | // Ensure the token is '123', which is what we have in `Rocket.toml`.
36 | let res = client.get("/token").dispatch();
37 | assert_eq!(res.into_string(), Some("123".into()));
38 | }
39 |
--------------------------------------------------------------------------------
/core/codegen/tests/ui-fail/typed-uris-invalid-syntax.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | #[get("/")]
4 | fn index() { }
5 |
6 | #[post("//")]
7 | fn simple(id: i32, name: String) -> &'static str { "" }
8 |
9 | fn main() {
10 | uri!(simple: id = 100, "Hello");
11 | uri!(simple(id = 100, "Hello"));
12 | uri!(simple("Hello", id = 100));
13 | uri!(simple,);
14 | uri!(simple:);
15 | uri!("/mount",);
16 | uri!("mount", simple);
17 | uri!("mount", simple, "http://");
18 | uri!("/mount", simple, "http://");
19 | uri!("/mount", simple, "#foo", "?foo");
20 | uri!("mount", simple(10, "hi"), "http://");
21 | uri!("/mount", simple(10, "hi"), "http://");
22 | uri!("/mount?foo", simple(10, "hi"), "foo/bar?foo#bar");
23 | uri!("/mount", simple(10, "hi"), "a/b");
24 | uri!("/mount", simple(10, "hi"), "#foo", "?foo");
25 | uri!("/mount/", simple);
26 | uri!();
27 | uri!(simple: id = );
28 | uri!(simple(id = ));
29 | uri!("*", simple(10), "hi");
30 | uri!("some.host:8088", simple(10), "hi");
31 | uri!("?foo");
32 | uri!("");
33 | uri!("/foo", "bar");
34 | uri!("/foo" ("bar"));
35 | uri!("ftp:?", index);
36 | uri!("ftp:", index, "foo#bar");
37 | uri!("ftp:", index, "foo?bar");
38 | }
39 |
--------------------------------------------------------------------------------
/scripts/bump_version.sh:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env bash
2 |
3 | #
4 | # Bumps the version number to ${1}.
5 | #
6 |
7 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
8 | source "${SCRIPT_DIR}/config.sh"
9 |
10 | if [ -z "${1}" ] ; then
11 | echo "Usage: $0 "
12 | echo "Example: $0 0.6.1"
13 | exit 1
14 | fi
15 |
16 | function do_replace_docs() {
17 | sd "${1}" "${2}" $(fd -t f -e toml -E '/news/*' . "${PROJECT_ROOT}")
18 | sd "${1}" "${2}" $(fd -t f -e md -E '/news/*' . "${SITE_ROOT}")
19 | }
20 |
21 | function do_replace_all() {
22 | sd "${1}" "${2}" $(fd -t f -e rs . "${PROJECT_ROOT}")
23 | do_replace_docs "${1}" "${2}"
24 | }
25 |
26 | NEW_VERSION="${1}"
27 | TODAY=$(date "+%b %d, %Y")
28 |
29 | if $PRE_RELEASE; then
30 | do_replace_all "/${PHYSICAL_CODENAME}" "/${CODENAME}"
31 | do_replace_docs "${PHYSICAL_CODENAME}" "${CODENAME}"
32 | else
33 | NEW_CODENAME="v$(echo "${NEW_VERSION}" | cut -d'.' -f1-2)"
34 | do_replace_all "/${VIRTUAL_CODENAME}" "/${CODENAME}"
35 | do_replace_all "/${CODENAME}" "/${NEW_CODENAME}"
36 | do_replace_docs "${VIRTUAL_CODENAME}" "${CODENAME}"
37 | do_replace_docs "${CODENAME}" "${NEW_CODENAME}"
38 | fi
39 |
40 | do_replace_all "${VERSION}" "${NEW_VERSION}"
41 | sd "^date.*" "date = \"${TODAY}\"" "${SITE_ROOT}/index.toml"
42 |
--------------------------------------------------------------------------------
/contrib/db_pools/lib/src/error.rs:
--------------------------------------------------------------------------------
1 | use std::fmt;
2 |
3 | /// A general error type for use by [`Pool`](crate::Pool#implementing)
4 | /// implementors and returned by the [`Connection`](crate::Connection) request
5 | /// guard.
6 | #[derive(Debug)]
7 | pub enum Error {
8 | /// An error that occured during database/pool initialization.
9 | Init(A),
10 |
11 | /// An error that ocurred while retrieving a connection from the pool.
12 | Get(B),
13 |
14 | /// A [`Figment`](crate::figment::Figment) configuration error.
15 | Config(crate::figment::Error),
16 | }
17 |
18 | impl fmt::Display for Error {
19 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20 | match self {
21 | Error::Init(e) => write!(f, "failed to initialize database: {}", e),
22 | Error::Get(e) => write!(f, "failed to get db connection: {}", e),
23 | Error::Config(e) => write!(f, "bad configuration: {}", e),
24 | }
25 | }
26 | }
27 |
28 | impl std::error::Error for Error
29 | where A: fmt::Debug + fmt::Display, B: fmt::Debug + fmt::Display {}
30 |
31 | impl From for Error {
32 | fn from(e: crate::figment::Error) -> Self {
33 | Self::Config(e)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/examples/config/src/tests.rs:
--------------------------------------------------------------------------------
1 | use rocket::config::{Config, LogLevel};
2 |
3 | async fn test_config(profile: &str) {
4 | let provider = Config::figment().select(profile);
5 | let rocket = rocket::custom(provider).ignite().await.unwrap();
6 | let config = rocket.config();
7 | match &*profile {
8 | "debug" => {
9 | assert_eq!(config.address, std::net::Ipv4Addr::LOCALHOST);
10 | assert_eq!(config.port, 8000);
11 | assert_eq!(config.workers, 1);
12 | assert_eq!(config.keep_alive, 0);
13 | assert_eq!(config.log_level, LogLevel::Normal);
14 | }
15 | "release" => {
16 | assert_eq!(config.address, std::net::Ipv4Addr::LOCALHOST);
17 | assert_eq!(config.port, 8000);
18 | assert_eq!(config.workers, 12);
19 | assert_eq!(config.keep_alive, 5);
20 | assert_eq!(config.log_level, LogLevel::Critical);
21 | assert!(!config.secret_key.is_zero());
22 | }
23 | _ => {
24 | panic!("Unknown profile: {}", profile);
25 | }
26 | }
27 | }
28 |
29 | #[async_test]
30 | async fn test_debug_config() {
31 | test_config("debug").await;
32 | }
33 |
34 | #[async_test]
35 | async fn test_release_config() {
36 | test_config("release").await;
37 | }
38 |
--------------------------------------------------------------------------------
/examples/testing/src/async_required.rs:
--------------------------------------------------------------------------------
1 | use rocket::{Rocket, State, Build};
2 | use rocket::fairing::AdHoc;
3 | use rocket::tokio::sync::Barrier;
4 |
5 | #[get("/barrier")]
6 | async fn rendezvous(barrier: &State) -> &'static str {
7 | println!("Waiting for second task...");
8 | barrier.wait().await;
9 | "Rendezvous reached."
10 | }
11 |
12 | pub fn rocket() -> Rocket {
13 | rocket::build()
14 | .mount("/", routes![rendezvous])
15 | .attach(AdHoc::on_ignite("Add Channel", |rocket| async {
16 | rocket.manage(Barrier::new(2))
17 | }))
18 | }
19 |
20 | #[cfg(test)]
21 | mod test {
22 | use super::rocket;
23 | use rocket::http::Status;
24 |
25 | #[rocket::async_test]
26 | async fn test_rendezvous() {
27 | use rocket::local::asynchronous::Client;
28 |
29 | let client = Client::tracked(rocket()).await.unwrap();
30 | let req = client.get("/barrier");
31 |
32 | let (r1, r2) = rocket::tokio::join!(req.clone().dispatch(), req.dispatch());
33 | assert_eq!(r1.status(), r2.status());
34 | assert_eq!(r1.status(), Status::Ok);
35 |
36 | let (s1, s2) = (r1.into_string().await, r2.into_string().await);
37 | assert_eq!(s1, s2);
38 | assert_eq!(s1.unwrap(), "Rendezvous reached.");
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/examples/tls/private/ecdsa_nistp256_sha256_cert.pem:
--------------------------------------------------------------------------------
1 | -----BEGIN CERTIFICATE-----
2 | MIIDYTCCAUmgAwIBAgIUWET3Ypdh7TK5UE24E9Smn1r03d0wDQYJKoZIhvcNAQEL
3 | BQAwRzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRIwEAYDVQQKDAlSb2NrZXQg
4 | Q0ExFzAVBgNVBAMMDlJvY2tldCBSb290IENBMB4XDTIxMDcwOTIzMzMzM1oXDTMx
5 | MDcwNzIzMzMzM1owPzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQ8wDQYDVQQK
6 | DAZSb2NrZXQxEjAQBgNVBAMMCWxvY2FsaG9zdDBZMBMGByqGSM49AgEGCCqGSM49
7 | AwEHA0IABDtAvrDALV/ZGurSJdoRFDvB2q7PsdjWWvzFWvQortUzmWXuFO47QJ8v
8 | lqluDtQKK7gHmNm10MrDk2o0ipMkrzSjGDAWMBQGA1UdEQQNMAuCCWxvY2FsaG9z
9 | dDANBgkqhkiG9w0BAQsFAAOCAgEAGJ/mFUyJzomXpYqGHzBRUvBqGmY05F2YOu0a
10 | D620WyWUFYWOnbqSKqqrP2nI1eNQXbmTtcKokuC67I2laIYML/IwBuLj+JcenvaB
11 | TmtmHHFSb0fweXSK3r0m9KEQBvVeoMEFhTZ6NINmXjTZES2xOks47yVo704q3xhS
12 | 7Rm7YGu3Wgjyn4YAb7UQhgnvN0x4UlDHQAU8PB4nLHgKkgaczaERcIa/nhGA1D85
13 | obNkh+QSNsShnrOrDJ4iRt5ZBLjmTX3qcbJTjjzaKwwMuBTOr7f5zh417ahPWq2v
14 | r0GgmMW+8k8D7CjBM5TkNzOTQRjLUUKF1YjX39E4J8E/rtg8/GlHVfKRG8bvGIK8
15 | EIiAaSjUTY00cQltlt9QMFOTGlakF8Id4Dxkke+oP+62EK1pOroQiRvNeopEy+dO
16 | Gee7HN5eC6n548VrMMql1TMoraWMK4kiVy46xlBmwHXq/JPG0GV/I6i24jobYeGt
17 | 8yoeB1DlCX9uiLOKlPctxMeVPkErvVGvVZZKMR2KYNznSj/L22VXSh0xg0L6zVRX
18 | DsW97MZsef1t2RZf7nSz4JkSecuUHNsk12Z/Pe3G7zofz2UtV1o3G9oBHSm91a/j
19 | L/sAlvawy8CwLll8DRk26mg7YLwgxnNfJzG9M0G8Fwi6XPUBx2ywsSTWSO0KQ+5C
20 | p2mcGCY=
21 | -----END CERTIFICATE-----
22 |
--------------------------------------------------------------------------------
/examples/tls/private/ecdsa_nistp384_sha384_cert.pem:
--------------------------------------------------------------------------------
1 | -----BEGIN CERTIFICATE-----
2 | MIIDfjCCAWagAwIBAgIUB+Ff5LDKhcdjusOuaCqjePqScwQwDQYJKoZIhvcNAQEM
3 | BQAwRzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRIwEAYDVQQKDAlSb2NrZXQg
4 | Q0ExFzAVBgNVBAMMDlJvY2tldCBSb290IENBMB4XDTIxMDcwOTIzMzMzM1oXDTMx
5 | MDcwNzIzMzMzM1owPzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQ8wDQYDVQQK
6 | DAZSb2NrZXQxEjAQBgNVBAMMCWxvY2FsaG9zdDB2MBAGByqGSM49AgEGBSuBBAAi
7 | A2IABNkp8NiqSoUc8bwJq0fIRFyvdDN0jUT4+9MdoJ/CJyKHjeVVBcMWXBJbKTmo
8 | rFbkJ6WcUbBU30K0+KTvqX9tFLXOmpwUZDyqmkeU78VV7DJrDKSy5Hgxz5hXJ309
9 | lz+Kr6MYMBYwFAYDVR0RBA0wC4IJbG9jYWxob3N0MA0GCSqGSIb3DQEBDAUAA4IC
10 | AQATXjqJmDfj0/C1KzSoFgvuiDK6NseMJijkKauaGdHUSGf2P06izvwke8xW3P/b
11 | VifOkpKX3K9RxY4R7xDenTXIEDnKYlp2a77djbef8mBL914ZQSXBFF8Lhz1QD/QC
12 | sIM8exCuelgHbfPh/UdLY1CmEcYOlHQYUpIMYkH7U0KbLvqafY3d7WkERuXwzAUd
13 | kYCAV2V23f2HiuOaX616QYW7Ow6jPrhU1RwEW25Y/Ubw+jQKDSRE6NF+inR7WPot
14 | 2GN0ELY+6trxe0w0DL0syOsfF9SVkvgfKhwBKVCsJvCp4HmOIBDlZL40NhrnXK6L
15 | HmUsyckVVMSmPRrvNrIy7m6CoCbdb8wWPlhpygMrOFfhpGJ2fIMzf4JzQnsAKHO9
16 | 1D5mtzaHNNcwBdWNTvVOojy0BRsRrNYcO/Lkf5+VwZ3+AQVPPwG04kk7fA/iONQx
17 | hraiVy6Majl4pFfbWcAOaSDDSMsZ8Joc6AmCiPQGVelrqzZ1wa+a12BBfibqYdm7
18 | ab831J7KrkK2rfCC84ZdUcICcWkPCisMfPeoaQsp2R4Zw7Rcuyfce8UVZYZsmZ9X
19 | rmgp6O3oIWK31iHkgpb+bQM0YXykbK/fp7vxqnfk2kq+IadSlDwOJ/U8sdNMVHdK
20 | mct9ke+F1KFB+J8UU5w/JK/Tn7HtWY8lf9VTuK8pAkyQAg==
21 | -----END CERTIFICATE-----
22 |
--------------------------------------------------------------------------------
/core/lib/tests/derive-reexports.rs:
--------------------------------------------------------------------------------
1 | use rocket;
2 |
3 | use rocket::{get, routes};
4 | use rocket::form::{FromForm, FromFormField};
5 | use rocket::response::Responder;
6 |
7 | #[derive(FromFormField)]
8 | enum Thing {
9 | A,
10 | B,
11 | C,
12 | }
13 |
14 | impl std::fmt::Display for Thing {
15 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16 | match *self {
17 | Thing::A => write!(f, "a"),
18 | Thing::B => write!(f, "b"),
19 | Thing::C => write!(f, "c"),
20 | }
21 | }
22 | }
23 |
24 | #[derive(FromForm)]
25 | struct ThingForm {
26 | thing: Thing,
27 | }
28 |
29 | #[derive(Responder)]
30 | struct DerivedResponder {
31 | data: String,
32 | }
33 |
34 | #[get("/")]
35 | fn index() -> DerivedResponder {
36 | DerivedResponder { data: "hello".to_string() }
37 | }
38 |
39 | #[get("/?")]
40 | fn number(params: ThingForm) -> DerivedResponder {
41 | DerivedResponder { data: params.thing.to_string() }
42 | }
43 |
44 | #[test]
45 | fn test_derive_reexports() {
46 | use rocket::local::blocking::Client;
47 |
48 | let client = Client::debug_with(routes![index, number]).unwrap();
49 |
50 | let response = client.get("/").dispatch();
51 | assert_eq!(response.into_string().unwrap(), "hello");
52 |
53 | let response = client.get("/?thing=b").dispatch();
54 | assert_eq!(response.into_string().unwrap(), "b");
55 | }
56 |
--------------------------------------------------------------------------------
/core/codegen/tests/route-raw.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | use rocket::local::blocking::Client;
4 |
5 | // Test that raw idents can be used for route parameter names
6 |
7 | #[get("/?")]
8 | fn get(r#enum: String, r#type: i32) -> String {
9 | format!("{} is {}", r#enum, r#type)
10 | }
11 |
12 | #[get("/swap//")]
13 | fn swap(r#raw: String, bare: String) -> String {
14 | format!("{}, {}", raw, bare)
15 | }
16 |
17 | #[catch(400)]
18 | fn catch(r#raw: &rocket::Request) -> String {
19 | format!("{}", raw.method())
20 | }
21 |
22 | #[test]
23 | fn test_raw_ident() {
24 | let rocket = rocket::build()
25 | .mount("/", routes![get, swap])
26 | .register("/", catchers![catch]);
27 |
28 | let client = Client::debug(rocket).unwrap();
29 |
30 | let response = client.get("/example?type=1").dispatch();
31 | assert_eq!(response.into_string().unwrap(), "example is 1");
32 |
33 | let uri_named = uri!(get(r#enum = "test_named", r#type = 1));
34 | assert_eq!(uri_named.to_string(), "/test_named?type=1");
35 |
36 | let uri_unnamed = uri!(get("test_unnamed", 2));
37 | assert_eq!(uri_unnamed.to_string(), "/test_unnamed?type=2");
38 |
39 | let uri_raws = uri!(swap(r#raw = "1", r#bare = "2"));
40 | assert_eq!(uri_raws.to_string(), "/swap/1/2");
41 | let uri_bare = uri!(swap(raw = "1", bare = "2"));
42 | assert_eq!(uri_bare.to_string(), "/swap/1/2");
43 | }
44 |
--------------------------------------------------------------------------------
/site/guide/11-conclusion.md:
--------------------------------------------------------------------------------
1 | # Conclusion
2 |
3 | We hope you agree that Rocket is a refreshing take on web frameworks. As with
4 | any software project, Rocket is _alive_. There are always things to improve, and
5 | we're happy to take the best ideas. If you have something in mind, please
6 | [submit an issue](https://github.com/SergioBenitez/Rocket/issues).
7 |
8 | ## Getting Help
9 |
10 | If you find yourself having trouble developing Rocket applications, you can get
11 | help via chat at [`#rocket:mozilla.org`] on Matrix or the bridged [`#rocket`]
12 | IRC channel on Libera.Chat at `irc.libera.chat`. We recommend joining us on
13 | [Matrix via Element]. If you prefer IRC, you can join via the [Kiwi IRC client]
14 | or a client of your own. The [FAQ](../faq/) also provides answers to commonly
15 | asked questions.
16 |
17 | [`#rocket:mozilla.org`]: https://chat.mozilla.org/#/room/#rocket:mozilla.org
18 | [`#rocket`]: https://kiwiirc.com/client/irc.libera.chat/#rocket
19 | [Matrix via Element]: https://chat.mozilla.org/#/room/#rocket:mozilla.org
20 | [Kiwi IRC Client]: https://kiwiirc.com/client/irc.libera.chat/#rocket
21 |
22 | ## What's next?
23 |
24 | The best way to learn Rocket is to _build something_. It should be fun and easy,
25 | and there's always someone to help. Alternatively, you can read through the
26 | [Rocket examples](@example) or the [Rocket source code](@github/core/lib/src).
27 | Whatever you decide to do next, we hope you have a blast!
28 |
--------------------------------------------------------------------------------
/core/lib/src/response/stream/one.rs:
--------------------------------------------------------------------------------
1 | use std::pin::Pin;
2 | use std::task::{Context, Poll};
3 |
4 | use futures::stream::Stream;
5 |
6 | /// A stream that yields exactly one value.
7 | ///
8 | /// A `ReaderStream` which wraps this type and yields one `AsyncRead` is
9 | /// returned by [`ReaderStream::one()`]. A `One` can also be constructed via
10 | /// [`One::from()`].
11 | ///
12 | /// [`ReaderStream::one()`]: crate::response::stream::ReaderStream::one()
13 | ///
14 | /// # Example
15 | ///
16 | /// ```rust
17 | /// use rocket::response::stream::One;
18 | /// use rocket::futures::stream::StreamExt;
19 | ///
20 | /// # rocket::async_test(async {
21 | /// let mut stream = One::from("hello!");
22 | /// let values: Vec<_> = stream.collect().await;
23 | /// assert_eq!(values, ["hello!"]);
24 | /// # });
25 | /// ```
26 | pub struct One(Option);
27 |
28 | /// Returns a `One` stream that will yield `value` exactly once.
29 | ///
30 | /// # Example
31 | ///
32 | /// ```rust
33 | /// use rocket::response::stream::One;
34 | ///
35 | /// let mut stream = One::from("hello!");
36 | /// ```
37 | impl From for One {
38 | fn from(value: T) -> Self {
39 | One(Some(value))
40 | }
41 | }
42 |
43 | impl Stream for One {
44 | type Item = T;
45 |
46 | fn poll_next(
47 | mut self: Pin<&mut Self>,
48 | _: &mut Context<'_>,
49 | ) -> Poll> {
50 | Poll::Ready(self.0.take())
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/core/lib/tests/local_request_private_cookie-issue-368.rs:
--------------------------------------------------------------------------------
1 | #![cfg(feature = "secrets")]
2 |
3 | use rocket::http::CookieJar;
4 |
5 | #[rocket::get("/")]
6 | fn return_private_cookie(cookies: &CookieJar<'_>) -> Option {
7 | match cookies.get_private("cookie_name") {
8 | Some(cookie) => Some(cookie.value().into()),
9 | None => None,
10 | }
11 | }
12 |
13 | mod tests {
14 | use super::*;
15 | use rocket::routes;
16 | use rocket::local::blocking::Client;
17 | use rocket::http::{Cookie, Status};
18 |
19 | #[test]
20 | fn private_cookie_is_returned() {
21 | let rocket = rocket::build().mount("/", routes![return_private_cookie]);
22 |
23 | let client = Client::debug(rocket).unwrap();
24 | let req = client.get("/").private_cookie(Cookie::new("cookie_name", "cookie_value"));
25 | let response = req.dispatch();
26 |
27 | assert_eq!(response.headers().get_one("Set-Cookie"), None);
28 | assert_eq!(response.into_string(), Some("cookie_value".into()));
29 | }
30 |
31 | #[test]
32 | fn regular_cookie_is_not_returned() {
33 | let rocket = rocket::build().mount("/", routes![return_private_cookie]);
34 |
35 | let client = Client::debug(rocket).unwrap();
36 | let req = client.get("/").cookie(Cookie::new("cookie_name", "cookie_value"));
37 | let response = req.dispatch();
38 |
39 | assert_eq!(response.status(), Status::NotFound);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/core/lib/src/response/mod.rs:
--------------------------------------------------------------------------------
1 | //! Types and traits to build and send responses.
2 | //!
3 | //! The return type of a Rocket handler can be any type that implements the
4 | //! [`Responder`](crate::response::Responder) trait, which means that the type knows
5 | //! how to generate a [`Response`]. Among other things, this module contains
6 | //! several such types.
7 | //!
8 | //! # Composing
9 | //!
10 | //! Many of the built-in `Responder` types _chain_ responses: they take in
11 | //! another `Responder` and add, remove, or change information in the response.
12 | //! In other words, many `Responder` types are built to compose well. As a
13 | //! result, you'll often have types of the form `A>` consisting of three
14 | //! `Responder`s `A`, `B`, and `C`. This is normal and encouraged as the type
15 | //! names typically illustrate the intended response.
16 |
17 | mod responder;
18 | mod redirect;
19 | mod response;
20 | mod debug;
21 | mod body;
22 |
23 | pub(crate) mod flash;
24 |
25 | pub mod content;
26 | pub mod status;
27 | pub mod stream;
28 |
29 | #[doc(hidden)]
30 | pub use rocket_codegen::Responder;
31 |
32 | pub use self::response::{Response, Builder};
33 | pub use self::body::Body;
34 | pub use self::responder::Responder;
35 | pub use self::redirect::Redirect;
36 | pub use self::flash::Flash;
37 | pub use self::debug::Debug;
38 |
39 | /// Type alias for the `Result` of a [`Responder::respond_to()`] call.
40 | pub type Result<'r> = std::result::Result, crate::http::Status>;
41 |
--------------------------------------------------------------------------------
/core/lib/tests/untracked-vs-tracked.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | use rocket::http::{Cookie, CookieJar};
4 |
5 | #[post("/")]
6 | fn add(jar: &CookieJar<'_>) {
7 | jar.add(Cookie::new("name", "value"));
8 | }
9 |
10 | #[get("/")]
11 | fn get<'a>(jar: &'a CookieJar<'_>) -> Option<&'a str> {
12 | jar.get("name").map(|c| c.value())
13 | }
14 |
15 | #[cfg(test)]
16 | mod many_cookie_jars_tests {
17 | use super::*;
18 | use rocket::{Rocket, local::blocking::Client, Build};
19 | use rocket::http::Status;
20 |
21 | fn rocket() -> Rocket {
22 | rocket::custom(rocket::Config::debug_default())
23 | .mount("/", routes![add, get])
24 | }
25 |
26 | #[test]
27 | fn test_tracked() {
28 | let client = Client::tracked(rocket()).unwrap();
29 |
30 | assert_eq!(client.get("/").dispatch().status(), Status::NotFound);
31 | assert_eq!(client.post("/").dispatch().status(), Status::Ok);
32 |
33 | let response = client.get("/").dispatch();
34 | assert_eq!(response.status(), Status::Ok);
35 | assert_eq!(response.into_string().unwrap(), "value");
36 | }
37 |
38 | #[test]
39 | fn test_untracked() {
40 | let client = Client::untracked(rocket()).unwrap();
41 |
42 | assert_eq!(client.get("/").dispatch().status(), Status::NotFound);
43 | assert_eq!(client.post("/").dispatch().status(), Status::Ok);
44 | assert_eq!(client.get("/").dispatch().status(), Status::NotFound);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/core/codegen/tests/ui-fail-stable/catch_type_errors.stderr:
--------------------------------------------------------------------------------
1 | error[E0277]: the trait bound `usize: Responder<'_, '_>` is not satisfied
2 | --> $DIR/catch_type_errors.rs:6:30
3 | |
4 | 6 | fn f1(_request: &Request) -> usize {
5 | | ^^^^^ the trait `Responder<'_, '_>` is not implemented for `usize`
6 | |
7 | = note: required by `respond_to`
8 |
9 | error[E0277]: the trait bound `bool: Responder<'_, '_>` is not satisfied
10 | --> $DIR/catch_type_errors.rs:11:30
11 | |
12 | 11 | fn f2(_request: &Request) -> bool {
13 | | ^^^^ the trait `Responder<'_, '_>` is not implemented for `bool`
14 | |
15 | = note: required by `respond_to`
16 |
17 | error[E0308]: mismatched types
18 | --> $DIR/catch_type_errors.rs:16:17
19 | |
20 | 16 | fn f3(_request: bool) -> usize {
21 | | ^^^^ expected `bool`, found `&rocket::Request<'_>`
22 |
23 | error[E0277]: the trait bound `usize: Responder<'_, '_>` is not satisfied
24 | --> $DIR/catch_type_errors.rs:16:26
25 | |
26 | 16 | fn f3(_request: bool) -> usize {
27 | | ^^^^^ the trait `Responder<'_, '_>` is not implemented for `usize`
28 | |
29 | = note: required by `respond_to`
30 |
31 | error[E0277]: the trait bound `usize: Responder<'_, '_>` is not satisfied
32 | --> $DIR/catch_type_errors.rs:21:12
33 | |
34 | 21 | fn f4() -> usize {
35 | | ^^^^^ the trait `Responder<'_, '_>` is not implemented for `usize`
36 | |
37 | = note: required by `respond_to`
38 |
--------------------------------------------------------------------------------
/core/codegen/tests/ui-fail/responder.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | #[derive(Responder)]
4 | struct Thing1;
5 |
6 | #[derive(Responder)]
7 | struct Thing2();
8 |
9 | #[derive(Responder)]
10 | enum Bar { } // NO ERROR
11 |
12 | #[derive(Responder)]
13 | enum Foo { Bark, }
14 |
15 | #[derive(Responder)]
16 | struct Thing4<'a, 'b>(&'a str, &'b str);
17 |
18 | #[derive(Responder)]
19 | struct Thing5(T); // NO ERROR
20 |
21 | #[derive(Responder)]
22 | struct Thing6(T, E);
23 |
24 | #[derive(Responder)]
25 | #[response(content_type = "")]
26 | struct Thing7(());
27 |
28 | #[derive(Responder)]
29 | #[response(content_type = "idk")]
30 | struct Thing8(());
31 |
32 | #[derive(Responder)]
33 | #[response(content_type = 100)]
34 | struct Thing9(());
35 |
36 | #[derive(Responder)]
37 | #[response(status = 8)]
38 | struct Thing10(());
39 |
40 | #[derive(Responder)]
41 | #[response(status = "404")]
42 | struct Thing11(());
43 |
44 | #[derive(Responder)]
45 | #[response(status = "404", content_type = "html")]
46 | struct Thing12(());
47 |
48 | #[derive(Responder)]
49 | #[response(status = 404, content_type = 120)]
50 | struct Thing13(());
51 |
52 | #[derive(Responder)] // NO ERROR
53 | enum Error<'r, T> {
54 | #[response(status = 400)]
55 | Unauthorized(T),
56 | #[response(status = 404)]
57 | NotFound(rocket::fs::NamedFile),
58 | #[response(status = 500)]
59 | A(&'r str, rocket::http::ContentType),
60 | }
61 |
62 | #[derive(Responder)] // NO ERROR
63 | enum Error2<'r, T> {
64 | Unauthorized(&'r T),
65 | }
66 |
67 | fn main() {}
68 |
--------------------------------------------------------------------------------
/examples/pastebin/src/main.rs:
--------------------------------------------------------------------------------
1 | #[macro_use] extern crate rocket;
2 |
3 | mod paste_id;
4 | #[cfg(test)] mod tests;
5 |
6 | use std::io;
7 |
8 | use rocket::data::{Data, ToByteUnit};
9 | use rocket::http::uri::Absolute;
10 | use rocket::response::content::RawText;
11 | use rocket::tokio::fs::{self, File};
12 |
13 | use crate::paste_id::PasteId;
14 |
15 | const HOST: Absolute<'static> = uri!("http://localhost:8000");
16 |
17 | const ID_LENGTH: usize = 3;
18 |
19 | #[post("/", data = "")]
20 | async fn upload(paste: Data<'_>) -> io::Result {
21 | let id = PasteId::new(ID_LENGTH);
22 | paste.open(128.kibibytes()).into_file(id.file_path()).await?;
23 | Ok(uri!(HOST, retrieve(id)).to_string())
24 | }
25 |
26 | #[get("/")]
27 | async fn retrieve(id: PasteId<'_>) -> Option> {
28 | File::open(id.file_path()).await.map(RawText).ok()
29 | }
30 |
31 | #[delete("/")]
32 | async fn delete(id: PasteId<'_>) -> Option<()> {
33 | fs::remove_file(id.file_path()).await.ok()
34 | }
35 |
36 | #[get("/")]
37 | fn index() -> &'static str {
38 | "
39 | USAGE
40 |
41 | POST /
42 |
43 | accepts raw data in the body of the request and responds with a URL of
44 | a page containing the body's content
45 |
46 | EXAMPLE: curl --data-binary @file.txt http://localhost:8000
47 |
48 | GET /
49 |
50 | retrieves the content for the paste with id ``
51 | "
52 | }
53 |
54 | #[launch]
55 | fn rocket() -> _ {
56 | rocket::build()
57 | .mount("/", routes![index, upload, delete, retrieve])
58 | }
59 |
--------------------------------------------------------------------------------
/core/http/src/hyper.rs:
--------------------------------------------------------------------------------
1 | //! Re-exported hyper HTTP library types.
2 | //!
3 | //! All types that are re-exported from Hyper reside inside of this module.
4 | //! These types will, with certainty, be removed with time, but they reside here
5 | //! while necessary.
6 |
7 | #[doc(hidden)] pub use hyper::*;
8 | #[doc(hidden)] pub use http::*;
9 |
10 | /// Reexported http header types.
11 | pub mod header {
12 | macro_rules! import_http_headers {
13 | ($($name:ident),*) => ($(
14 | pub use hyper::header::$name as $name;
15 | )*)
16 | }
17 |
18 | import_http_headers! {
19 | ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES,
20 | ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
21 | ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
22 | ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE,
23 | ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD, ALLOW,
24 | AUTHORIZATION, CACHE_CONTROL, CONNECTION, CONTENT_DISPOSITION,
25 | CONTENT_ENCODING, CONTENT_LANGUAGE, CONTENT_LENGTH, CONTENT_LOCATION,
26 | CONTENT_RANGE, CONTENT_SECURITY_POLICY,
27 | CONTENT_SECURITY_POLICY_REPORT_ONLY, CONTENT_TYPE, DATE, ETAG, EXPECT,
28 | EXPIRES, FORWARDED, FROM, HOST, IF_MATCH, IF_MODIFIED_SINCE,
29 | IF_NONE_MATCH, IF_RANGE, IF_UNMODIFIED_SINCE, LAST_MODIFIED, LINK,
30 | LOCATION, ORIGIN, PRAGMA, RANGE, REFERER, REFERRER_POLICY, REFRESH,
31 | STRICT_TRANSPORT_SECURITY, TE, TRANSFER_ENCODING, UPGRADE, USER_AGENT,
32 | VARY
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/core/http/src/parse/uri/mod.rs:
--------------------------------------------------------------------------------
1 | mod parser;
2 | mod error;
3 | pub(crate) mod tables;
4 |
5 | #[cfg(test)] mod tests;
6 |
7 | use crate::uri::{Uri, Origin, Absolute, Authority, Reference, Asterisk};
8 |
9 | use self::parser::*;
10 |
11 | pub use self::error::Error;
12 |
13 | type RawInput<'a> = pear::input::Pear>;
14 |
15 | #[inline]
16 | pub fn from_str(s: &str) -> Result, Error<'_>> {
17 | Ok(parse!(uri: RawInput::new(s.as_bytes()))?)
18 | }
19 |
20 | #[inline]
21 | pub fn origin_from_str(s: &str) -> Result, Error<'_>> {
22 | Ok(parse!(origin: RawInput::new(s.as_bytes()))?)
23 | }
24 |
25 | #[inline]
26 | pub fn authority_from_str(s: &str) -> Result, Error<'_>> {
27 | Ok(parse!(authority: RawInput::new(s.as_bytes()))?)
28 | }
29 |
30 | #[inline]
31 | pub fn authority_from_bytes(s: &[u8]) -> Result, Error<'_>> {
32 | Ok(parse!(authority: RawInput::new(s))?)
33 | }
34 |
35 | #[inline]
36 | pub fn scheme_from_str(s: &str) -> Result<&str, Error<'_>> {
37 | let _validated = parse!(scheme: RawInput::new(s.as_bytes()))?;
38 | Ok(s)
39 | }
40 |
41 | #[inline]
42 | pub fn absolute_from_str(s: &str) -> Result, Error<'_>> {
43 | Ok(parse!(absolute: RawInput::new(s.as_bytes()))?)
44 | }
45 |
46 | #[inline]
47 | pub fn asterisk_from_str(s: &str) -> Result> {
48 | Ok(parse!(asterisk: RawInput::new(s.as_bytes()))?)
49 | }
50 |
51 | #[inline]
52 | pub fn reference_from_str(s: &str) -> Result, Error<'_>> {
53 | Ok(parse!(reference: RawInput::new(s.as_bytes()))?)
54 | }
55 |
--------------------------------------------------------------------------------
/examples/chat/static/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Rocket Rooms
6 |
7 |
8 |
9 |
10 |
11 |
12 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
46 |
5 |