]> git.proxmox.com Git - rustc.git/blob - src/rustbook/book.rs
Imported Upstream version 1.8.0+dfsg1
[rustc.git] / src / rustbook / book.rs
1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 //! Basic data structures for representing a book.
12
13 use std::io::prelude::*;
14 use std::io::BufReader;
15 use std::iter;
16 use std::path::{Path, PathBuf};
17
18 pub struct BookItem {
19 pub title: String,
20 pub path: PathBuf,
21 pub path_to_root: PathBuf,
22 pub children: Vec<BookItem>,
23 }
24
25 pub struct Book {
26 pub chapters: Vec<BookItem>,
27 }
28
29 /// A depth-first iterator over a book.
30 pub struct BookItems<'a> {
31 cur_items: &'a [BookItem],
32 cur_idx: usize,
33 stack: Vec<(&'a [BookItem], usize)>,
34 }
35
36 impl<'a> Iterator for BookItems<'a> {
37 type Item = (String, &'a BookItem);
38
39 fn next(&mut self) -> Option<(String, &'a BookItem)> {
40 loop {
41 if self.cur_idx >= self.cur_items.len() {
42 match self.stack.pop() {
43 None => return None,
44 Some((parent_items, parent_idx)) => {
45 self.cur_items = parent_items;
46 self.cur_idx = parent_idx + 1;
47 }
48 }
49 } else {
50 let cur = self.cur_items.get(self.cur_idx).unwrap();
51
52 let mut section = "".to_string();
53 for &(_, idx) in &self.stack {
54 section.push_str(&(idx + 1).to_string()[..]);
55 section.push('.');
56 }
57 section.push_str(&(self.cur_idx + 1).to_string()[..]);
58 section.push('.');
59
60 self.stack.push((self.cur_items, self.cur_idx));
61 self.cur_items = &cur.children[..];
62 self.cur_idx = 0;
63 return Some((section, cur))
64 }
65 }
66 }
67 }
68
69 impl Book {
70 pub fn iter(&self) -> BookItems {
71 BookItems {
72 cur_items: &self.chapters[..],
73 cur_idx: 0,
74 stack: Vec::new(),
75 }
76 }
77 }
78
79 /// Construct a book by parsing a summary (markdown table of contents).
80 pub fn parse_summary(input: &mut Read, src: &Path) -> Result<Book, Vec<String>> {
81 fn collapse(stack: &mut Vec<BookItem>,
82 top_items: &mut Vec<BookItem>,
83 to_level: usize) {
84 loop {
85 if stack.len() < to_level { return }
86 if stack.len() == 1 {
87 top_items.push(stack.pop().unwrap());
88 return;
89 }
90
91 let tip = stack.pop().unwrap();
92 let last = stack.len() - 1;
93 stack[last].children.push(tip);
94 }
95 }
96
97 let mut top_items = vec!();
98 let mut stack = vec!();
99 let mut errors = vec!();
100
101 // always include the introduction
102 top_items.push(BookItem {
103 title: "Introduction".to_string(),
104 path: PathBuf::from("README.md"),
105 path_to_root: PathBuf::from(""),
106 children: vec!(),
107 });
108
109 for line_result in BufReader::new(input).lines() {
110 let line = match line_result {
111 Ok(line) => line,
112 Err(err) => {
113 errors.push(err.to_string());
114 return Err(errors);
115 }
116 };
117
118 let star_idx = match line.find("*") { Some(i) => i, None => continue };
119
120 let start_bracket = star_idx + line[star_idx..].find("[").unwrap();
121 let end_bracket = start_bracket + line[start_bracket..].find("](").unwrap();
122 let start_paren = end_bracket + 1;
123 let end_paren = start_paren + line[start_paren..].find(")").unwrap();
124
125 let given_path = &line[start_paren + 1 .. end_paren];
126 let title = line[start_bracket + 1..end_bracket].to_string();
127 let indent = &line[..star_idx];
128
129 let path_from_root = match src.join(given_path).strip_prefix(src) {
130 Ok(p) => p.to_path_buf(),
131 Err(..) => {
132 errors.push(format!("paths in SUMMARY.md must be relative, \
133 but path '{}' for section '{}' is not.",
134 given_path, title));
135 PathBuf::new()
136 }
137 };
138 let path_to_root = PathBuf::from(&iter::repeat("../")
139 .take(path_from_root.components().count() - 1)
140 .collect::<String>());
141 let item = BookItem {
142 title: title,
143 path: path_from_root,
144 path_to_root: path_to_root,
145 children: vec!(),
146 };
147 let level = indent.chars().map(|c| -> usize {
148 match c {
149 ' ' => 1,
150 '\t' => 4,
151 _ => unreachable!()
152 }
153 }).sum::<usize>() / 4 + 1;
154
155 if level > stack.len() + 1 {
156 errors.push(format!("section '{}' is indented too deeply; \
157 found {}, expected {} or less",
158 item.title, level, stack.len() + 1));
159 } else if level <= stack.len() {
160 collapse(&mut stack, &mut top_items, level);
161 }
162 stack.push(item)
163 }
164
165 if errors.is_empty() {
166 collapse(&mut stack, &mut top_items, 1);
167 Ok(Book { chapters: top_items })
168 } else {
169 Err(errors)
170 }
171 }