Skip to content

Instantly share code, notes, and snippets.

@durka

durka/error.rs

Forked from anonymous/expanded.rs
Created July 19, 2017 22:36
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save durka/c4a7adb095ac76209c6e7385bfd9e3ee to your computer and use it in GitHub Desktop.
Save durka/c4a7adb095ac76209c6e7385bfd9e3ee to your computer and use it in GitHub Desktop.
Download ZIP
Raw
error.rs
warning: unreachable pattern
--> src/routes.rs:66:1
|
66 | / handle_login! {
67 | | #[get("/<date>/<flow>/<idx>")]
68 | | pub fn episode/episode_login(user: User, users: State<ActiveUsers>, date: Datestamp, flow: Option<FlowType>, idx: u32) -> Template {
69 | | let flow = flow.ok_or(ErrorKind::BadParam("invalid flow type"))?;
... |
132 | | }
133 | | }
| |_^ in this macro invocation
|
= note: this error originates in a macro outside of the current crate
Raw
expanded.rs
#[allow(unreachable_code)]
fn rocket_route_fn_episode_login<'_b>(__req: &'_b ::rocket::Request,
__data: ::rocket::Data)
-> ::rocket::handler::Outcome<'_b> {
let rocket_param_date: Datestamp =
match match __req.get_param_str(0usize) {
Some(s) =>
<Datestamp as
::rocket::request::FromParam>::from_param(s),
None => return ::rocket::Outcome::Forward(__data),
} {
Ok(v) => v,
Err(e) => {
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[" => Failed to parse \'",
"\': ",
"\n"];
__STATIC_FMTSTR
},
&match (&"date",
&e) {
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
}));
return ::rocket::Outcome::Forward(__data)
}
};
let rocket_param_flow: Option<FlowType> =
match match __req.get_param_str(1usize) {
Some(s) =>
<Option<FlowType> as
::rocket::request::FromParam>::from_param(s),
None => return ::rocket::Outcome::Forward(__data),
} {
Ok(v) => v,
Err(e) => {
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[" => Failed to parse \'",
"\': ",
"\n"];
__STATIC_FMTSTR
},
&match (&"flow",
&e) {
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
}));
return ::rocket::Outcome::Forward(__data)
}
};
let rocket_param_idx: u32 =
match match __req.get_param_str(2usize) {
Some(s) =>
<u32 as ::rocket::request::FromParam>::from_param(s),
None => return ::rocket::Outcome::Forward(__data),
} {
Ok(v) => v,
Err(e) => {
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[" => Failed to parse \'",
"\': ",
"\n"];
__STATIC_FMTSTR
},
&match (&"idx",
&e) {
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
}));
return ::rocket::Outcome::Forward(__data)
}
};
#[allow(non_snake_case)]
let rocket_param_uri: &URI =
match ::rocket::request::FromRequest::from_request(__req) {
::rocket::Outcome::Success(v) => v,
::rocket::Outcome::Forward(_) =>
return ::rocket::Outcome::Forward(__data),
::rocket::Outcome::Failure((code, _)) => {
return ::rocket::Outcome::Failure(code)
}
};
#[allow(non_snake_case)]
let rocket_param_users: State<ActiveUsers> =
match ::rocket::request::FromRequest::from_request(__req) {
::rocket::Outcome::Success(v) => v,
::rocket::Outcome::Forward(_) =>
return ::rocket::Outcome::Forward(__data),
::rocket::Outcome::Failure((code, _)) => {
return ::rocket::Outcome::Failure(code)
}
};
let responder =
episode_login(rocket_param_uri, rocket_param_users,
rocket_param_date, rocket_param_flow,
rocket_param_idx);
::rocket::handler::Outcome::from(__req, responder)
}
/// Rocket code generated static route information structure.
#[allow(non_upper_case_globals)]
#[rocket_route_info]
pub static static_rocket_route_info_for_episode_login:
::rocket::StaticRouteInfo =
::rocket::StaticRouteInfo{method: ::rocket::http::Method::Get,
path: "/<date>/<flow>/<idx>",
handler: rocket_route_fn_episode_login,
format: None,
rank: Some(1isize),};
#[allow(unused_variables)]
#[rocket_route(static_rocket_route_info_for_episode_login)]
pub fn episode_login(uri: &URI, users: State<ActiveUsers>,
date: Datestamp, flow: Option<FlowType>, idx: u32)
-> Redirect {
Redirect::to(&::fmt::format(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&["/login?uri="];
__STATIC_FMTSTR
},
&match (&URI::percent_encode(uri.as_str()),)
{
(__arg0,)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt)],
})))
}
#[allow(unreachable_code)]
fn rocket_route_fn_episode<'_b>(__req: &'_b ::rocket::Request,
__data: ::rocket::Data)
-> ::rocket::handler::Outcome<'_b> {
let rocket_param_date: Datestamp =
match match __req.get_param_str(0usize) {
Some(s) =>
<Datestamp as
::rocket::request::FromParam>::from_param(s),
None => return ::rocket::Outcome::Forward(__data),
} {
Ok(v) => v,
Err(e) => {
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[" => Failed to parse \'",
"\': ",
"\n"];
__STATIC_FMTSTR
},
&match (&"date",
&e) {
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
}));
return ::rocket::Outcome::Forward(__data)
}
};
let rocket_param_flow: Option<FlowType> =
match match __req.get_param_str(1usize) {
Some(s) =>
<Option<FlowType> as
::rocket::request::FromParam>::from_param(s),
None => return ::rocket::Outcome::Forward(__data),
} {
Ok(v) => v,
Err(e) => {
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[" => Failed to parse \'",
"\': ",
"\n"];
__STATIC_FMTSTR
},
&match (&"flow",
&e) {
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
}));
return ::rocket::Outcome::Forward(__data)
}
};
let rocket_param_idx: u32 =
match match __req.get_param_str(2usize) {
Some(s) =>
<u32 as ::rocket::request::FromParam>::from_param(s),
None => return ::rocket::Outcome::Forward(__data),
} {
Ok(v) => v,
Err(e) => {
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[" => Failed to parse \'",
"\': ",
"\n"];
__STATIC_FMTSTR
},
&match (&"idx",
&e) {
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
}));
return ::rocket::Outcome::Forward(__data)
}
};
#[allow(non_snake_case)]
let rocket_param_user: User =
match ::rocket::request::FromRequest::from_request(__req) {
::rocket::Outcome::Success(v) => v,
::rocket::Outcome::Forward(_) =>
return ::rocket::Outcome::Forward(__data),
::rocket::Outcome::Failure((code, _)) => {
return ::rocket::Outcome::Failure(code)
}
};
#[allow(non_snake_case)]
let rocket_param_users: State<ActiveUsers> =
match ::rocket::request::FromRequest::from_request(__req) {
::rocket::Outcome::Success(v) => v,
::rocket::Outcome::Forward(_) =>
return ::rocket::Outcome::Forward(__data),
::rocket::Outcome::Failure((code, _)) => {
return ::rocket::Outcome::Failure(code)
}
};
let responder =
episode(rocket_param_user, rocket_param_users, rocket_param_date,
rocket_param_flow, rocket_param_idx);
::rocket::handler::Outcome::from(__req, responder)
}
/// Rocket code generated static route information structure.
#[allow(non_upper_case_globals)]
#[rocket_route_info]
pub static static_rocket_route_info_for_episode: ::rocket::StaticRouteInfo
=
::rocket::StaticRouteInfo{method: ::rocket::http::Method::Get,
path: "/<date>/<flow>/<idx>",
handler: rocket_route_fn_episode,
format: None,
rank: None,};
#[rocket_route(static_rocket_route_info_for_episode)]
pub fn episode(user: User, users: State<ActiveUsers>, date: Datestamp,
flow: Option<FlowType>, idx: u32)
-> StdResult<Template, Failure> {
do catch {
let flow = flow.ok_or(ErrorKind::BadParam("invalid flow type"))?;
let mut data =
{
let mut data = None;
for dir in settings::DATADIRS {
let mut path = PathBuf::from(dir);
path.push(::fmt::format(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[""];
__STATIC_FMTSTR
},
&match (&date.0,)
{
(__arg0,)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt)],
})));
path.push(::fmt::format(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[""];
__STATIC_FMTSTR
},
&match (&flow,)
{
(__arg0,)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt)],
})));
path.push(::fmt::format(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&[""];
__STATIC_FMTSTR
},
&match (&idx,)
{
(__arg0,)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt)],
})));
path.push(::fmt::format(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&["",
".flow"];
__STATIC_FMTSTR
},
&match (&flow,)
{
(__arg0,)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt)],
})));
data =
match SurfaceData::from_flow_file(date, flow, idx,
&path) {
Ok(d) => Some(d),
Err(e) =>
match *e.kind() {
ErrorKind::Io(ref ioe) =>
match ioe.kind() {
io::ErrorKind::NotFound => continue ,
_ => break ,
},
_ => break ,
},
};
}
data.ok_or(io::Error::new(io::ErrorKind::NotFound,
"episode not found in any datadir"))?
};
for rating in data.ratings.iter_mut() {
if rating.prompt == "cool/warm" {
rating.short = Some("warm");
rating.long =
Some("What temperature would you feel when touching this surface? 1: ice cold beer bottle. 5: hot sand at the beach.");
} else if rating.prompt == "soft/hard" {
rating.short = Some("hard");
rating.long =
Some("How soft or hard is this surface? 1: pillow. 5: rock.");
} else if rating.prompt == "smooth/rough" {
rating.short = Some("rough");
rating.long =
Some("How smooth or rough is this surface? 1: glass. 5: sandpaper.");
} else if rating.prompt == "slippery/sticky" {
rating.short = Some("sticky");
rating.long =
Some("How slippery or sticky is this surface? This is NOT the same as roughness, nor is it sticky as in glue. This question refers to how much a finger would get stuck while rubbing due to friction with the surface. 1: silk. 5: rubber.");
}
}
let mut users = users.lock().unwrap();
let user_info =
users.entry(user.clone()).or_insert_with(Default::default);
let rate_error =
if user_info.rate_error {
user_info.rate_error = false;
"All ratings are required"
} else { "" };
let report_error =
if user_info.report_error {
user_info.report_error = false;
"At least one reason is required"
} else { "" };
Ok(Template::render("episode",
::Value::Object({
let mut object =
::Map::new();
object.insert(("rate_error").into(),
::to_value(&rate_error).unwrap());
object.insert(("report_error").into(),
::to_value(&report_error).unwrap());
object.insert(("user").into(),
::to_value(&user).unwrap());
object.insert(("surface").into(),
::to_value(&data).unwrap());
object.insert(("date").into(),
::to_value(&date.0).unwrap());
object.insert(("flow").into(),
::to_value(&flow.to_string()).unwrap());
object.insert(("idx").into(),
::to_value(&idx).unwrap());
object
})))
}.map_err(|err: Error|
{
::io::_print(::std::fmt::Arguments::new_v1({
static __STATIC_FMTSTR:
&'static [&'static str]
=
&["ERROR: ",
"\n"];
__STATIC_FMTSTR
},
&match (&err,)
{
(__arg0,)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Debug::fmt)],
}));
let mut code = 500;
match *err.kind() {
ErrorKind::Io(ref ioerr) =>
match ioerr.kind() {
io::ErrorKind::NotFound => code = 404,
io::ErrorKind::PermissionDenied =>
code = 403,
_ => { }
},
ErrorKind::BadParam { .. } => code = 400,
_ => { }
}
Failure(Status::from_code(code).unwrap())
})
}
@Arnavion
Copy link

Arnavion commented Jul 19, 2017 •
edited

Line 449? (That is, does ErrorKind only have Io and BadParam variants or are there others?)

https://play.integer32.com/?gist=d58dc30bad88b795f09728c1bf128eaf&version=nightly

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment