User interface

src/web/crate_details.rs

@@ -1,7 +1,8 @@
 
 
 
-use super::{NoCrate, MetaData, duration_to_str, match_version, render_markdown};
+use super::{MetaData, duration_to_str, match_version, render_markdown};
+use super::error::Nope;
 use super::page::Page;
 use db::connect_db;
 use iron::prelude::*;
@@ -194,7 +195,7 @@ pub fn crate_details_handler(req: &mut Request) -> IronResult<Response> {
 
     match_version(&conn, &name, req_version)
         .and_then(|version| CrateDetails::new(&conn, &name, &version))
-        .ok_or(IronError::new(NoCrate, status::NotFound))
+        .ok_or(IronError::new(Nope::CrateNotFound, status::NotFound))
         .and_then(|details| {
             Page::new(details)
                 .set_true("show_package_navigation")

src/web/error.rs

@@ -0,0 +1,68 @@
+use std::error::Error;
+use iron::prelude::*;
+use iron::Handler;
+use iron::status;
+use web::page::Page;
+use std::fmt;
+
+#[derive(Debug, Copy, Clone)]
+pub enum Nope {
+    ResourceNotFound,
+    CrateNotFound,
+    NoResults,
+}
+
+impl fmt::Display for Nope {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.description())
+    }
+}
+
+impl Error for Nope {
+    fn description(&self) -> &str {
+        match *self {
+            Nope::ResourceNotFound => "Requested resource not found",
+            Nope::CrateNotFound => "Requested crate not found",
+            Nope::NoResults => "Search yielded no results",
+        }
+    }
+}
+
+impl Handler for Nope {
+    fn handle(&self, req: &mut Request) -> IronResult<Response> {
+        match *self {
+            Nope::ResourceNotFound => {
+                // user tried to navigate to a resource (doc page/file) that doesn't exist
+                Page::new("no such resource".to_owned())
+                    .set_status(status::NotFound)
+                    .title("The requested resource does not exist")
+                    .to_resp("error")
+            }
+            Nope::CrateNotFound => {
+                // user tried to navigate to a crate that doesn't exist
+                Page::new("no such crate".to_owned())
+                    .set_status(status::NotFound)
+                    .title("The requested crate does not exist")
+                    .to_resp("error")
+            }
+            Nope::NoResults => {
+                use params::{Params, Value};
+                let params = req.get::<Params>().unwrap();
+                if let Some(&Value::String(ref query)) = params.find(&["query"]) {
+                    // this used to be a search
+                    Page::new(Vec::<super::releases::Release>::new())
+                        .set_status(status::NotFound)
+                        .set("search_query", &query)
+                        .title(&format!("No crates found matching '{}'", query))
+                        .to_resp("releases")
+                } else {
+                    // user did a search with no search terms
+                    Page::new(Vec::<super::releases::Release>::new())
+                        .set_status(status::NotFound)
+                        .title("No results given for empty search query")
+                        .to_resp("releases")
+                }
+            }
+        }
+    }
+}

src/web/file.rs

@@ -81,7 +81,7 @@ impl Handler for DatabaseFileHandler {
         if let Some(file) = File::from_path(&conn, &path) {
             Ok(file.serve())
         } else {
-            Err(IronError::new(super::NoCrate, status::NotFound))
+            Err(IronError::new(super::error::Nope::CrateNotFound, status::NotFound))
         }
     }
 }

src/web/mod.rs

@@ -9,13 +9,14 @@ mod source;
 mod pool;
 mod file;
 mod builds;
+mod error;
 
-use std::{env, fmt};
+use std::env;
 use std::error::Error;
 use std::time::Duration;
 use std::path::PathBuf;
 use iron::prelude::*;
-use iron::{status, Handler};
+use iron::Handler;
 use router::Router;
 use staticfile::Static;
 use handlebars_iron::{HandlebarsEngine, DirectorySource};
@@ -31,22 +32,6 @@ use std::collections::BTreeMap;
 const STATIC_FILE_CACHE_DURATION: u64 = 60 * 60 * 24 * 3;   // 3 days
 
 
-// This is a generic error used in routes
-#[derive(Debug)]
-struct NoCrate;
-
-impl fmt::Display for NoCrate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("Crate not found.")
-    }
-}
-
-impl Error for NoCrate {
-    fn description(&self) -> &str { "No Crate" }
-}
-
-
-
 struct CratesfyiHandler {
     router_handler: Box<Handler>,
     database_file_handler: Box<Handler>,
@@ -55,6 +40,22 @@ struct CratesfyiHandler {
 
 
 impl CratesfyiHandler {
+    fn chain<H: Handler>(base: H) -> Chain {
+        // TODO: Use DocBuilderOptions for paths
+        let mut hbse = HandlebarsEngine::new();
+        hbse.add(Box::new(DirectorySource::new("./templates", ".hbs")));
+
+        // load templates
+        if let Err(e) = hbse.reload() {
+            panic!("Failed to load handlebar templates: {}", e.description());
+        }
+
+        let mut chain = Chain::new(base);
+        chain.link_before(pool::Pool::new());
+        chain.link_after(hbse);
+        chain
+    }
+
     pub fn new() -> CratesfyiHandler {
         let mut router = Router::new();
         router.get("/", releases::home_page);
@@ -79,19 +80,7 @@ impl CratesfyiHandler {
         router.get("/source/:name/:version/*", source::source_browser_handler);
         router.get("/search", releases::search_handler);
 
-        // TODO: Use DocBuilderOptions for paths
-        let mut hbse = HandlebarsEngine::new();
-        hbse.add(Box::new(DirectorySource::new("./templates", ".hbs")));
-
-        // load templates
-        if let Err(e) = hbse.reload() {
-            panic!("Failed to load handlebar templates: {}", e.description());
-        }
-
-        let mut router_chain = Chain::new(router);
-        router_chain.link_before(pool::Pool::new());
-        router_chain.link_after(hbse);
-
+        let router_chain = Self::chain(router);
         let prefix = PathBuf::from(env::var("CRATESFYI_PREFIX").unwrap()).join("public_html");
         let static_handler = Static::new(prefix)
             .cache(Duration::from_secs(STATIC_FILE_CACHE_DURATION));
@@ -107,23 +96,25 @@ impl CratesfyiHandler {
 
 impl Handler for CratesfyiHandler {
     fn handle(&self, req: &mut Request) -> IronResult<Response> {
-        // try router first then staticfile handler
+        // try router first then db/static file handler
         // return 404 if none of them return Ok
-        match self.router_handler.handle(req) {
-            Ok(res) => return Ok(res),
-            Err(e) => debug!("{}", e.description())
-        };
-
-        // if router fails try to serve files from database first
-        // and then try static handler. if all of them fails, return 404
-        // TODO: Add a custom 404 page
-        if let Ok(res) = self.database_file_handler.handle(req) {
-            Ok(res)
-        } else if let Ok(res) = self.static_handler.handle(req) {
-            Ok(res)
-        } else {
-            Ok(Response::with((status::NotFound, "404 FAILED IN CRATESFYIHANDLER")))
-        }
+        self.router_handler
+            .handle(req)
+            .or_else(|e| {
+                // if router fails try to serve files from database first
+                self.database_file_handler.handle(req).or(Err(e))
+            })
+            .or_else(|e| {
+                // and then try static handler. if all of them fails, return 404
+                self.static_handler.handle(req).or(Err(e))
+            })
+            .or_else(|e| {
+                debug!("{}", e.description());
+                let err: error::Nope = *e.error
+                    .downcast::<error::Nope>()
+                    .expect("all cratesfyi errors should be of type Nope");
+                Self::chain(err).handle(req)
+            })
     }
 }
 

src/web/page.rs

@@ -10,6 +10,7 @@ use handlebars_iron::Template;
 pub struct Page<T: ToJson> {
     title: Option<String>,
     content: T,
+    status: status::Status,
     varss: BTreeMap<String, String>,
     varsb: BTreeMap<String, bool>,
     varsi: BTreeMap<String, i64>,
@@ -21,6 +22,7 @@ impl<T: ToJson> Page<T> {
         Page {
             title: None,
             content: content,
+            status: status::Ok,
             varss: BTreeMap::new(),
             varsb: BTreeMap::new(),
             varsi: BTreeMap::new(),
@@ -62,10 +64,18 @@ impl<T: ToJson> Page<T> {
     }
 
 
-    pub fn to_resp(self, template: &str) -> IronResult<Response> { 
+    /// Sets status code for response
+    pub fn set_status(mut self, s: status::Status) -> Page<T> {
+        self.status = s;
+        self
+    }
+
+
+    pub fn to_resp(self, template: &str) -> IronResult<Response> {
         let mut resp = Response::new();
+        let status = self.status;
         let temp = Template::new(template, self);
-        resp.set_mut(temp).set_mut(status::Ok);
+        resp.set_mut(temp).set_mut(status);
         Ok(resp)
     }
 }

src/web/releases.rs

@@ -1,7 +1,8 @@
 //! Releases web handlers
 
 
-use super::{NoCrate, duration_to_str, match_version};
+use super::{duration_to_str, match_version};
+use super::error::Nope;
 use super::page::Page;
 use super::pool::Pool;
 use iron::prelude::*;
@@ -19,7 +20,7 @@ const RELEASES_IN_HOME: i64 = 15;
 const RELEASES_IN_RELEASES: i64 = 30;
 
 
-struct Release {
+pub struct Release {
     name: String,
     version: String,
     description: Option<String>,
@@ -243,7 +244,7 @@ pub fn releases_handler(req: &mut Request) -> IronResult<Response> {
     let packages = get_releases(conn, page_number, RELEASES_IN_RELEASES, Order::ReleaseTime);
 
     if packages.is_empty() {
-        return Err(IronError::new(NoCrate, status::NotFound));
+        return Err(IronError::new(Nope::CrateNotFound, status::NotFound));
     }
 
     // Show next and previous page buttons
@@ -280,7 +281,7 @@ pub fn stars_handler(req: &mut Request) -> IronResult<Response> {
     let packages = get_releases(conn, page_number, RELEASES_IN_RELEASES, Order::GithubStars);
 
     if packages.is_empty() {
-        return Err(IronError::new(NoCrate, status::NotFound));
+        return Err(IronError::new(Nope::CrateNotFound, status::NotFound));
     }
 
     // Show next and previous page buttons
@@ -317,7 +318,7 @@ pub fn author_handler(req: &mut Request) -> IronResult<Response> {
     let author = req.extensions.get::<Router>().unwrap().find("author");
 
     if author.is_none() {
-        return Err(IronError::new(NoCrate, status::NotFound));
+        return Err(IronError::new(Nope::CrateNotFound, status::NotFound));
     }
 
     let (author_name, packages) = get_releases_by_author(conn,
@@ -326,7 +327,7 @@ pub fn author_handler(req: &mut Request) -> IronResult<Response> {
                                                          author.unwrap());
 
     if packages.is_empty() {
-        return Err(IronError::new(NoCrate, status::NotFound));
+        return Err(IronError::new(Nope::CrateNotFound, status::NotFound));
     }
 
     // Show next and previous page buttons
@@ -383,7 +384,7 @@ pub fn search_handler(req: &mut Request) -> IronResult<Response> {
 
         let search_query = query.replace(" ", " & ");
         get_search_results(&conn, &search_query, 1, RELEASES_IN_RELEASES)
-            .ok_or(IronError::new(NoCrate, status::NotFound))
+            .ok_or(IronError::new(Nope::NoResults, status::NotFound))
             .and_then(|(_, results)| {
                 // FIXME: There is no pagination
                 Page::new(results)
@@ -392,6 +393,6 @@ pub fn search_handler(req: &mut Request) -> IronResult<Response> {
                     .to_resp("releases")
             })
     } else {
-        Err(IronError::new(NoCrate, status::NotFound))
+        Err(IronError::new(Nope::NoResults, status::NotFound))
     }
 }

src/web/rustdoc.rs

@@ -8,7 +8,8 @@ use iron::prelude::*;
 use iron::{status, Url};
 use iron::modifiers::Redirect;
 use router::Router;
-use super::{NoCrate, match_version};
+use super::match_version;
+use super::error::Nope;
 use super::page::Page;
 use rustc_serialize::json::{Json, ToJson};
 use std::collections::BTreeMap;
@@ -88,7 +89,7 @@ pub fn rustdoc_redirector_handler(req: &mut Request) -> IronResult<Response> {
 
     let version = match match_version(&conn, &crate_name, req_version) {
         Some(v) => v,
-        None => return Err(IronError::new(NoCrate, status::NotFound)),
+        None => return Err(IronError::new(Nope::CrateNotFound, status::NotFound)),
     };
 
     // get target name
@@ -119,14 +120,14 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
 
     // don't touch anything other than html files
     if !path.ends_with(".html") {
-        return Err(IronError::new(NoCrate, status::NotFound));
+        return Err(IronError::new(Nope::ResourceNotFound, status::NotFound));
     }
 
     let conn = req.extensions.get::<Pool>().unwrap();
 
     let file = match File::from_path(&conn, &path) {
         Some(f) => f,
-        None => return Err(IronError::new(NoCrate, status::NotFound)),
+        None => return Err(IronError::new(Nope::ResourceNotFound, status::NotFound)),
     };
 
     let (mut in_head, mut in_body) = (false, false);

templates/error.hbs

@@ -0,0 +1,2 @@
+{{> header}}
+{{> footer}}