Rocket/examples/hello_person/src/main.rs

#![feature(plugin)]
#![plugin(rocket_codegen)]

extern crate rocket;

#[cfg(test)] mod tests;

#[get("/hello/<name>/<age>")]
fn hello(name: String, age: u8) -> String {
    format!("Hello, {} year old named {}!", age, name)
}

#[get("/hello/<name>")]
fn hi(name: String) -> String {
    name
}

fn main() {
    rocket::ignite().mount("/", routes![hello, hi]).launch();
}
Rocket is almost operational! `routes!` macro complete. Here's what works so far: * The `route` decorator checks its inputs correctly. There's a nice utility for doing this, and it's working quite well at the moment. * The `route` decorator emits a `route_fn` and a `route_struct`. The `routes` * macro prepends the path terminator with the route struct prefix. The * `Rocket` library can read mount information (though not act on it properly just yet) and launch a server using Hyper. 2016-03-12 18:45:19 +00:00			`#![feature(plugin)]`
Renamed macros to codegen. 2016-09-09 03:38:58 +00:00			`#![plugin(rocket_codegen)]`
Rocket is almost operational! `routes!` macro complete. Here's what works so far: * The `route` decorator checks its inputs correctly. There's a nice utility for doing this, and it's working quite well at the moment. * The `route` decorator emits a `route_fn` and a `route_struct`. The `routes` * macro prepends the path terminator with the route struct prefix. The * `Rocket` library can read mount information (though not act on it properly just yet) and launch a server using Hyper. 2016-03-12 18:45:19 +00:00
			`extern crate rocket;`
Something works! A simple hacked-up handler, that is. At the moment, I simply install the first route I see into the Rocket struct directly. This is quite terrible. What's worse is that I assume that the Route's path and handler are static! The handler, actually, does have to be static, but its response may have whatever (valid) lifetime, though I'm not sure anything but `static makes sense. I'll think about it. In any case, the weird `static` restrictions need to be removed, and I need to think about which lifetimes are safe here. IE: Must all routes be static? Can I use a closure as a route? (that'd be neat). If so, how do we make that work? In any case, it's nice to see SOMETHING work. Yay! 2016-03-15 07:41:22 +00:00
Add tests to the hello_world, helllo_ranks, and hello_person examples. 2016-10-17 22:14:57 +00:00			`#[cfg(test)] mod tests;`

Complete rewrite of macro parsing and item generation. 2016-09-04 08:05:17 +00:00			`#[get("/hello/<name>/<age>")]`
Use the `RawStr` type for raw parameter strings. This is a breaking change. The `&str` type no longer implements `FromParam`. The `&RawStr` type should be used in its place. 2017-03-31 07:18:58 +00:00			`fn hello(name: String, age: u8) -> String {`
Cleaned up to get rid of warnings. 2016-03-18 03:37:34 +00:00			`format!("Hello, {} year old named {}!", age, name)`
initial implementation of collision detection in routing. 2016-03-17 10:29:55 +00:00			`}`

Strip lifetimes for generated param types. 2016-09-07 06:24:20 +00:00			`#[get("/hello/<name>")]`
Use the `RawStr` type for raw parameter strings. This is a breaking change. The `&str` type no longer implements `FromParam`. The `&RawStr` type should be used in its place. 2017-03-31 07:18:58 +00:00			`fn hi(name: String) -> String {`
Strip lifetimes for generated param types. 2016-09-07 06:24:20 +00:00			`name`
			`}`

Rocket is almost operational! `routes!` macro complete. Here's what works so far: * The `route` decorator checks its inputs correctly. There's a nice utility for doing this, and it's working quite well at the moment. * The `route` decorator emits a `route_fn` and a `route_struct`. The `routes` * macro prepends the path terminator with the route struct prefix. The * `Rocket` library can read mount information (though not act on it properly just yet) and launch a server using Hyper. 2016-03-12 18:45:19 +00:00			`fn main() {`
Revert hello_person to pre-testing. 2016-12-19 09:57:13 +00:00			`rocket::ignite().mount("/", routes![hello, hi]).launch();`
Rocket is almost operational! `routes!` macro complete. Here's what works so far: * The `route` decorator checks its inputs correctly. There's a nice utility for doing this, and it's working quite well at the moment. * The `route` decorator emits a `route_fn` and a `route_struct`. The `routes` * macro prepends the path terminator with the route struct prefix. The * `Rocket` library can read mount information (though not act on it properly just yet) and launch a server using Hyper. 2016-03-12 18:45:19 +00:00			`}`