Handle errors properly in rustbook.

Silently ignoring errors is :( so lets not silently ignore them. huon is
:) now.

src/rustbook/book.rs

@@ -124,7 +124,7 @@ pub fn parse_summary<R: Reader>(input: R, src: &Path) -> Result<Book, Vec<String
             let path_from_root = match src.join(given_path.unwrap()).path_relative_from(src) {
                 Some(p) => p,
                 None => {
-                    errors.push(format!("Paths in SUMMARY.md must be relative, \
+                    errors.push(format!("paths in SUMMARY.md must be relative, \
                                          but path '{}' for section '{}' is not.",
                                          given_path.unwrap(), title));
                     Path::new("")
@@ -148,8 +148,9 @@ pub fn parse_summary<R: Reader>(input: R, src: &Path) -> Result<Book, Vec<String
             }).sum() / 4 + 1;
 
             if level > stack.len() + 1 {
-                // FIXME: better error message
-                errors.push(format!("Section '{}' is indented too many levels.", item.title));
+                errors.push(format!("section '{}' is indented too deeply; \
+                                     found {}, expected {} or less",
+                                    item.title, level, stack.len() + 1));
             } else if level <= stack.len() {
                 collapse(&mut stack, &mut top_items, level);
             }

src/rustbook/build.rs

@@ -73,10 +73,7 @@ fn write_toc(book: &Book, path_to_root: &Path, out: &mut Writer) -> IoResult<()>
 }
 
 fn render(book: &Book, tgt: &Path) -> CliResult<()> {
-    let tmp = TempDir::new("rust-book")
-                      .ok()
-                      // FIXME: lift to Result instead
-                      .expect("could not create temporary directory");
+    let tmp = try!(TempDir::new("rust-book"));
 
     for (section, item) in book.iter() {
         println!("{} {}", section, item.title);
@@ -163,30 +160,24 @@ impl Subcommand for Build {
             tgt = Path::new(os::args()[3].clone());
         }
 
-        let _ = fs::mkdir(&tgt, io::USER_DIR); // FIXME: handle errors
+        try!(fs::mkdir(&tgt, io::USER_DIR));
 
-        // FIXME: handle errors
-        let _ = File::create(&tgt.join("rust-book.css")).write_str(css::STYLE);
+        try!(File::create(&tgt.join("rust-book.css")).write_str(css::STYLE));
 
-        let summary = File::open(&src.join("SUMMARY.md"));
+        let summary = try!(File::open(&src.join("SUMMARY.md")));
         match book::parse_summary(summary, &src) {
             Ok(book) => {
                 // execute rustdoc on the whole book
-                try!(render(&book, &tgt).map_err(|err| {
-                    term.err(&format!("error: {}", err.description())[]);
-                    err.detail().map(|detail| {
-                        term.err(&format!("detail: {}", detail)[]);
-                    });
-                    err
-                }))
+                render(&book, &tgt)
             }
             Err(errors) => {
+                let n = errors.len();
                 for err in errors.into_iter() {
-                    term.err(&err[]);
+                    term.err(&format!("error: {}", err)[]);
                 }
+
+                Err(box format!("{} errors occurred", n) as Box<Error>)
             }
         }
-
-        Ok(()) // lol
     }
 }

src/rustbook/error.rs

@@ -79,4 +79,5 @@ impl Error for IoError {
     }
 }
 
+
 //fn iter_map_err<T, U, E, I: Iterator<Result<T,E>>>(iter: I,

src/rustbook/main.rs

@@ -54,7 +54,12 @@ fn main() {
                     Ok(_) => {
                         match subcmd.execute(&mut term) {
                             Ok(_) => (),
-                            Err(_) => os::set_exit_status(-1),
+                            Err(err) => {
+                                term.err(&format!("error: {}", err.description())[]);
+                                err.detail().map(|detail| {
+                                    term.err(&format!("detail: {}", detail)[]);
+                                });
+                            }
                         }
                     }
                     Err(err) => {