actions
/
mdBook
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add a rustfmt config and run rustfmt on the code base

This commit is contained in:
Mathieu David 2016-03-17 22:31:28 +01:00
parent 6bac41caa8
commit ad0794a0bd
13 changed files with 556 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
rustfmt.toml Normal file
View File

@ -0,0 +1,15 @@
write_mode = "Overwrite"
max_width = 120
ideal_width = 120
fn_call_width = 100
fn_args_density = "Compressed"
enum_trailing_comma = true
match_block_trailing_comma = true
struct_trailing_comma = "Always"
wrap_comments = true
report_todo = "Always"
report_fixme = "Always"

14
src/bin/mdbook.rs
View File

@ -61,7 +61,7 @@ fn main() {
#[cfg(feature = "watch")] #[cfg(feature = "watch")]
("watch", Some(sub_matches)) => watch(sub_matches), ("watch", Some(sub_matches)) => watch(sub_matches),
("test", Some(sub_matches)) => test(sub_matches), ("test", Some(sub_matches)) => test(sub_matches),
(_, _) => unreachable!() (_, _) => unreachable!(),
}; };
if let Err(e) = res { if let Err(e) = res {
@ -77,7 +77,7 @@ fn confirm() -> bool {
io::stdin().read_line(&mut s).ok(); io::stdin().read_line(&mut s).ok();
match &*s.trim() { match &*s.trim() {
"Y" | "y" | "yes" | "Yes" => true, "Y" | "y" | "yes" | "Yes" => true,
_ => false _ => false,
} }
} }
@ -178,7 +178,9 @@ fn watch(args: &ArgMatches) -> Result<(), Box<Error>> {
Ok(event) => { Ok(event) => {
// Skip the event if an event has already been issued in the last second // Skip the event if an event has already been issued in the last second
if time::get_time().sec - previous_time < 1 { continue } if time::get_time().sec - previous_time < 1 {
continue;
}
if let Some(path) = event.path { if let Some(path) = event.path {
// Trigger the build process in a new thread (to keep receiving events) // Trigger the build process in a new thread (to keep receiving events)
@ -186,7 +188,7 @@ fn watch(args: &ArgMatches) -> Result<(), Box<Error>> {
println!("File changed: {:?}\nBuilding book...\n", path); println!("File changed: {:?}\nBuilding book...\n", path);
match build(args) { match build(args) {
Err(e) => println!("Error while building: {:?}", e), Err(e) => println!("Error while building: {:?}", e),
_ => {} _ => {},
} }
println!(""); println!("");
}); });
@ -197,7 +199,7 @@ fn watch(args: &ArgMatches) -> Result<(), Box<Error>> {
}, },
Err(e) => { Err(e) => {
println!("An error occured: {:?}", e); println!("An error occured: {:?}", e);
} },
} }
} }
}); });
@ -206,7 +208,7 @@ fn watch(args: &ArgMatches) -> Result<(), Box<Error>> {
Err(e) => { Err(e) => {
println!("Error while trying to watch the files:\n\n\t{:?}", e); println!("Error while trying to watch the files:\n\n\t{:?}", e);
::std::process::exit(0); ::std::process::exit(0);
} },
} }
Ok(()) Ok(())

23
src/book/bookconfig.rs
View File

@ -40,7 +40,7 @@ impl BookConfig {
Ok(f) => f, Ok(f) => f,
Err(_) => { Err(_) => {
debug!("[*]: Failed to open {:?}", root.join("book.json")); debug!("[*]: Failed to open {:?}", root.join("book.json"));
return self return self;
}, },
}; };
@ -49,7 +49,9 @@ impl BookConfig {
// Just return if an error occured. // Just return if an error occured.
// I would like to propagate the error, but I have to return `&self` // I would like to propagate the error, but I have to return `&self`
if let Err(_) = config_file.read_to_string(&mut data) { return self } if let Err(_) = config_file.read_to_string(&mut data) {
return self;
}
// Convert to JSON // Convert to JSON
if let Ok(config) = Json::from_str(&data) { if let Ok(config) = Json::from_str(&data) {
@ -57,9 +59,15 @@ impl BookConfig {
debug!("[*]: Extracting data from config"); debug!("[*]: Extracting data from config");
// Title, author, description // Title, author, description
if let Some(a) = config.find_path(&["title"]) { self.title = a.to_string().replace("\"", "") } if let Some(a) = config.find_path(&["title"]) {
if let Some(a) = config.find_path(&["author"]) { self.author = a.to_string().replace("\"", "") } self.title = a.to_string().replace("\"", "")
if let Some(a) = config.find_path(&["description"]) { self.description = a.to_string().replace("\"", "") } }
if let Some(a) = config.find_path(&["author"]) {
self.author = a.to_string().replace("\"", "")
}
if let Some(a) = config.find_path(&["description"]) {
self.description = a.to_string().replace("\"", "")
}
// Destination // Destination
if let Some(a) = config.find_path(&["dest"]) { if let Some(a) = config.find_path(&["dest"]) {
@ -71,7 +79,9 @@ impl BookConfig {
let dest = self.get_root().join(&dest).to_owned(); let dest = self.get_root().join(&dest).to_owned();
self.set_dest(&dest); self.set_dest(&dest);
}, },
false => { self.set_dest(&dest); }, false => {
self.set_dest(&dest);
},
} }
} }
} }
@ -105,5 +115,4 @@ impl BookConfig {
self.src = src.to_owned(); self.src = src.to_owned();
self self
} }
} }

16
src/book/bookitem.rs
View File

@ -27,7 +27,6 @@ pub struct BookItems<'a> {
impl Chapter { impl Chapter {
pub fn new(name: String, path: PathBuf) -> Self { pub fn new(name: String, path: PathBuf) -> Self {
Chapter { Chapter {
@ -40,13 +39,14 @@ impl Chapter {
impl ToJson for Chapter { impl ToJson for Chapter {
fn to_json(&self) -> Json { fn to_json(&self) -> Json {
let mut m: BTreeMap<String, Json> = BTreeMap::new(); let mut m: BTreeMap<String, Json> = BTreeMap::new();
m.insert("name".to_owned(), self.name.to_json()); m.insert("name".to_owned(), self.name.to_json());
m.insert("path".to_owned(),self.path.to_str() m.insert("path".to_owned(),
.expect("Json conversion failed for path").to_json() self.path
); .to_str()
.expect("Json conversion failed for path")
.to_json());
m.to_json() m.to_json()
} }
} }
@ -66,7 +66,7 @@ impl<'a> Iterator for BookItems<'a> {
Some((parent_items, parent_idx)) => { Some((parent_items, parent_idx)) => {
self.items = parent_items; self.items = parent_items;
self.current_index = parent_idx + 1; self.current_index = parent_idx + 1;
} },
} }
} else { } else {
let cur = self.items.get(self.current_index).unwrap(); let cur = self.items.get(self.current_index).unwrap();
@ -79,10 +79,10 @@ impl<'a> Iterator for BookItems<'a> {
}, },
BookItem::Spacer => { BookItem::Spacer => {
self.current_index += 1; self.current_index += 1;
} },
} }
return Some(cur) return Some(cur);
} }
} }
} }

29
src/book/mdbook.rs
View File

@ -18,7 +18,6 @@ pub struct MDBook {
} }
impl MDBook { impl MDBook {
/// Create a new `MDBook` struct with root directory `root` /// Create a new `MDBook` struct with root directory `root`
/// ///
/// - The default source directory is set to `root/src` /// - The default source directory is set to `root/src`
@ -152,7 +151,7 @@ impl MDBook {
try!(writeln!(f, "# {}", ch.name)); try!(writeln!(f, "# {}", ch.name));
} }
} }
} },
} }
} }
@ -172,20 +171,19 @@ impl MDBook {
return; return;
} }
let relative = self.get_dest().strip_prefix(self.get_root()) let relative = self.get_dest()
.strip_prefix(self.get_root())
.expect("Destination is not relative to root."); .expect("Destination is not relative to root.");
let relative = relative.to_str() let relative = relative.to_str()
.expect("Path could not be yielded into a string slice."); .expect("Path could not be yielded into a string slice.");
debug!("[*]: {:?} does not exist, trying to create .gitignore", gitignore); debug!("[*]: {:?} does not exist, trying to create .gitignore", gitignore);
let mut f = File::create(&gitignore) let mut f = File::create(&gitignore).expect("Could not create file.");
.expect("Could not create file.");
debug!("[*]: Writing to .gitignore"); debug!("[*]: Writing to .gitignore");
writeln!(f, "{}", relative) writeln!(f, "{}", relative).expect("Could not write to file.");
.expect("Could not write to file.");
} }
} }
@ -322,8 +320,8 @@ impl MDBook {
String::from_utf8_lossy(&output.stderr)))) as Box<Error>); String::from_utf8_lossy(&output.stderr)))) as Box<Error>);
} }
} }
} },
_ => {} _ => {},
} }
} }
Ok(()) Ok(())
@ -337,11 +335,13 @@ impl MDBook {
// Handle absolute and relative paths // Handle absolute and relative paths
match dest.is_absolute() { match dest.is_absolute() {
true => { self.config.set_dest(dest); }, true => {
self.config.set_dest(dest);
},
false => { false => {
let dest = self.config.get_root().join(dest).to_owned(); let dest = self.config.get_root().join(dest).to_owned();
self.config.set_dest(&dest); self.config.set_dest(&dest);
} },
} }
self self
@ -355,11 +355,13 @@ impl MDBook {
// Handle absolute and relative paths // Handle absolute and relative paths
match src.is_absolute() { match src.is_absolute() {
true => { self.config.set_src(src); }, true => {
self.config.set_src(src);
},
false => { false => {
let src = self.config.get_root().join(src).to_owned(); let src = self.config.get_root().join(src).to_owned();
self.config.set_src(&src); self.config.set_src(&src);
} },
} }
self self
@ -402,5 +404,4 @@ impl MDBook {
self.content = try!(parse::construct_bookitems(&self.config.get_src().join("SUMMARY.md"))); self.content = try!(parse::construct_bookitems(&self.config.get_src().join("SUMMARY.md")));
Ok(()) Ok(())
} }
} }

91
src/parse/summary.rs
View File

@ -26,7 +26,9 @@ fn parse_level(summary: &mut Vec<&str>, current_level: i32, mut section: Vec<i32
// if level < current_level we remove the last digit of section, exit the current function, // if level < current_level we remove the last digit of section, exit the current function,
// and return the parsed level to the calling function. // and return the parsed level to the calling function.
if level < current_level { break } if level < current_level {
break;
}
// if level > current_level we call ourselves to go one level deeper // if level > current_level we call ourselves to go one level deeper
if level > current_level { if level > current_level {
@ -42,13 +44,15 @@ fn parse_level(summary: &mut Vec<&str>, current_level: i32, mut section: Vec<i32
// Remove the last number from the section, because we got back to our level.. // Remove the last number from the section, because we got back to our level..
section.pop(); section.pop();
continue continue;
} else { } else {
return Err(Error::new( ErrorKind::Other, format!( return Err(Error::new(ErrorKind::Other,
"Your summary.md is messed up\n\n format!("Your summary.md is messed up\n\n
Prefix, Suffix and Spacer elements can only exist on the root level.\n Prefix, \
Prefix elements can only exist before any chapter and there can be no chapters after suffix elements." Suffix and Spacer elements can only exist on the root level.\n
))) \
Prefix elements can only exist before any chapter and there can be \
no chapters after suffix elements.")));
}; };
} else { } else {
@ -59,26 +63,32 @@ fn parse_level(summary: &mut Vec<&str>, current_level: i32, mut section: Vec<i32
match parsed_item { match parsed_item {
// error if level != 0 and BookItem is != Chapter // error if level != 0 and BookItem is != Chapter
BookItem::Affix(_) | BookItem::Spacer if level > 0 => { BookItem::Affix(_) | BookItem::Spacer if level > 0 => {
return Err(Error::new( ErrorKind::Other, format!( return Err(Error::new(ErrorKind::Other,
"Your summary.md is messed up\n\n format!("Your summary.md is messed up\n\n
Prefix, Suffix and Spacer elements can only exist on the root level.\n \
Prefix elements can only exist before any chapter and there can be no chapters after suffix elements." Prefix, Suffix and Spacer elements can only exist on the \
))) root level.\n
Prefix \
elements can only exist before any chapter and there can be \
no chapters after suffix elements.")))
}, },
// error if BookItem == Chapter and section == -1 // error if BookItem == Chapter and section == -1
BookItem::Chapter(_, _) if section[0] == -1 => { BookItem::Chapter(_, _) if section[0] == -1 => {
return Err(Error::new( ErrorKind::Other, format!( return Err(Error::new(ErrorKind::Other,
"Your summary.md is messed up\n\n format!("Your summary.md is messed up\n\n
Prefix, Suffix and Spacer elements can only exist on the root level.\n \
Prefix elements can only exist before any chapter and there can be no chapters after suffix elements." Prefix, Suffix and Spacer elements can only exist on the \
))) root level.\n
Prefix \
elements can only exist before any chapter and there can be \
no chapters after suffix elements.")))
}, },
// Set section = -1 after suffix // Set section = -1 after suffix
BookItem::Affix(_) if section[0] > 0 => { BookItem::Affix(_) if section[0] > 0 => {
section[0] = -1; section[0] = -1;
} },
_ => {}, _ => {},
} }
@ -90,8 +100,8 @@ fn parse_level(summary: &mut Vec<&str>, current_level: i32, mut section: Vec<i32
section[len] += 1; section[len] += 1;
let s = section.iter().fold("".to_owned(), |s, i| s + &i.to_string() + "."); let s = section.iter().fold("".to_owned(), |s, i| s + &i.to_string() + ".");
BookItem::Chapter(s, ch) BookItem::Chapter(s, ch)
} },
_ => parsed_item _ => parsed_item,
} }
} else { } else {
@ -131,11 +141,7 @@ fn level(line: &str, spaces_in_tab: i32) -> Result<i32> {
debug!("[SUMMARY.md]:"); debug!("[SUMMARY.md]:");
debug!("\t[line]: {}", line); debug!("\t[line]: {}", line);
debug!("[*]: There is an indentation error on this line. Indentation should be {} spaces", spaces_in_tab); debug!("[*]: There is an indentation error on this line. Indentation should be {} spaces", spaces_in_tab);
return Err(Error::new( return Err(Error::new(ErrorKind::Other, format!("Indentation error on line:\n\n{}", line)));
ErrorKind::Other,
format!("Indentation error on line:\n\n{}", line)
)
)
} }
Ok(level) Ok(level)
@ -146,12 +152,12 @@ fn parse_line(l: &str) -> Option<BookItem> {
debug!("[fn]: parse_line"); debug!("[fn]: parse_line");
// Remove leading and trailing spaces or tabs // Remove leading and trailing spaces or tabs
let line = l.trim_matches(|c: char| { c == ' ' || c == '\t' }); let line = l.trim_matches(|c: char| c == ' ' || c == '\t');
// Spacers are "------" // Spacers are "------"
if line.starts_with("--") { if line.starts_with("--") {
debug!("[*]: Line is spacer"); debug!("[*]: Line is spacer");
return Some(BookItem::Spacer) return Some(BookItem::Spacer);
} }
if let Some(c) = line.chars().nth(0) { if let Some(c) = line.chars().nth(0) {
@ -161,18 +167,22 @@ fn parse_line(l: &str) -> Option<BookItem> {
debug!("[*]: Line is list element"); debug!("[*]: Line is list element");
if let Some((name, path)) = read_link(line) { if let Some((name, path)) = read_link(line) {
return Some(BookItem::Chapter("0".to_owned(), Chapter::new(name, path))) return Some(BookItem::Chapter("0".to_owned(), Chapter::new(name, path)));
} else { return None } } else {
return None;
}
}, },
// Non-list element // Non-list element
'[' => { '[' => {
debug!("[*]: Line is a link element"); debug!("[*]: Line is a link element");
if let Some((name, path)) = read_link(line) { if let Some((name, path)) = read_link(line) {
return Some(BookItem::Affix(Chapter::new(name, path))) return Some(BookItem::Affix(Chapter::new(name, path)));
} else { return None } } else {
return None;
} }
_ => {} },
_ => {},
} }
} }
@ -185,18 +195,18 @@ fn read_link(line: &str) -> Option<(String, PathBuf)> {
// In the future, support for list item that is not a link // In the future, support for list item that is not a link
// Not sure if I should error on line I can't parse or just ignore them... // Not sure if I should error on line I can't parse or just ignore them...
if let Some(i) = line.find('[') { start_delimitor = i; } if let Some(i) = line.find('[') {
else { start_delimitor = i;
} else {
debug!("[*]: '[' not found, this line is not a link. Ignoring..."); debug!("[*]: '[' not found, this line is not a link. Ignoring...");
return None return None;
} }
if let Some(i) = line[start_delimitor..].find("](") { if let Some(i) = line[start_delimitor..].find("](") {
end_delimitor = start_delimitor + i; end_delimitor = start_delimitor + i;
} } else {
else {
debug!("[*]: '](' not found, this line is not a link. Ignoring..."); debug!("[*]: '](' not found, this line is not a link. Ignoring...");
return None return None;
} }
let name = line[start_delimitor + 1..end_delimitor].to_owned(); let name = line[start_delimitor + 1..end_delimitor].to_owned();
@ -204,10 +214,9 @@ fn read_link(line: &str) -> Option<(String, PathBuf)> {
start_delimitor = end_delimitor + 1; start_delimitor = end_delimitor + 1;
if let Some(i) = line[start_delimitor..].find(')') { if let Some(i) = line[start_delimitor..].find(')') {
end_delimitor = start_delimitor + i; end_delimitor = start_delimitor + i;
} } else {
else {
debug!("[*]: ')' not found, this line is not a link. Ignoring..."); debug!("[*]: ')' not found, this line is not a link. Ignoring...");
return None return None;
} }
let path = PathBuf::from(line[start_delimitor + 1..end_delimitor].to_owned()); let path = PathBuf::from(line[start_delimitor + 1..end_delimitor].to_owned());

133
src/renderer/html_handlebars/hbs_renderer.rs
View File

@ -51,7 +51,8 @@ impl Renderer for HtmlHandlebars {
// Check if dest directory exists // Check if dest directory exists
debug!("[*]: Check if destination directory exists"); debug!("[*]: Check if destination directory exists");
if let Err(_) = fs::create_dir_all(book.get_dest()) { if let Err(_) = fs::create_dir_all(book.get_dest()) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Unexpected error when constructing destination path"))) return Err(Box::new(io::Error::new(io::ErrorKind::Other,
"Unexpected error when constructing destination path")));
} }
// Render a file for every entry in the book // Render a file for every entry in the book
@ -83,8 +84,13 @@ impl Renderer for HtmlHandlebars {
// Remove content from previous file and render content for this one // Remove content from previous file and render content for this one
data.remove("path"); data.remove("path");
match ch.path.to_str() { match ch.path.to_str() {
Some(p) => { data.insert("path".to_owned(), p.to_json()); }, Some(p) => {
None => return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not convert path to str"))), data.insert("path".to_owned(), p.to_json());
},
None => {
return Err(Box::new(io::Error::new(io::ErrorKind::Other,
"Could not convert path to str")))
},
} }
@ -118,19 +124,20 @@ impl Renderer for HtmlHandlebars {
// This could cause a problem when someone displays code containing <base href=...> // This could cause a problem when someone displays code containing <base href=...>
// on the front page, however this case should be very very rare... // on the front page, however this case should be very very rare...
content = content.lines().filter(|line| !line.contains("<base href=")).collect::<Vec<&str>>().join("\n"); content = content.lines()
.filter(|line| !line.contains("<base href="))
.collect::<Vec<&str>>()
.join("\n");
try!(index_file.write_all(content.as_bytes())); try!(index_file.write_all(content.as_bytes()));
output!( output!("[*] Creating index.html from {:?} ✓",
"[*] Creating index.html from {:?} ✓", book.get_dest().join(&ch.path.with_extension("html")));
book.get_dest().join(&ch.path.with_extension("html"))
);
index = false; index = false;
} }
} }
} },
_ => {} _ => {},
} }
} }
@ -159,72 +166,112 @@ impl Renderer for HtmlHandlebars {
debug!("[*] Copy static files"); debug!("[*] Copy static files");
// JavaScript // JavaScript
let mut js_file = if let Ok(f) = File::create(book.get_dest().join("book.js")) { f } else { let mut js_file = if let Ok(f) = File::create(book.get_dest().join("book.js")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create book.js"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create book.js")));
}; };
try!(js_file.write_all(&theme.js)); try!(js_file.write_all(&theme.js));
// Css // Css
let mut css_file = if let Ok(f) = File::create(book.get_dest().join("book.css")) { f } else { let mut css_file = if let Ok(f) = File::create(book.get_dest().join("book.css")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create book.css"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create book.css")));
}; };
try!(css_file.write_all(&theme.css)); try!(css_file.write_all(&theme.css));
// Favicon // Favicon
let mut favicon_file = if let Ok(f) = File::create(book.get_dest().join("favicon.png")) { f } else { let mut favicon_file = if let Ok(f) = File::create(book.get_dest().join("favicon.png")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create favicon.png"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create favicon.png")));
}; };
try!(favicon_file.write_all(&theme.favicon)); try!(favicon_file.write_all(&theme.favicon));
// JQuery local fallback // JQuery local fallback
let mut jquery = if let Ok(f) = File::create(book.get_dest().join("jquery.js")) { f } else { let mut jquery = if let Ok(f) = File::create(book.get_dest().join("jquery.js")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create jquery.js"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create jquery.js")));
}; };
try!(jquery.write_all(&theme.jquery)); try!(jquery.write_all(&theme.jquery));
// syntax highlighting // syntax highlighting
let mut highlight_css = if let Ok(f) = File::create(book.get_dest().join("highlight.css")) { f } else { let mut highlight_css = if let Ok(f) = File::create(book.get_dest().join("highlight.css")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create highlight.css"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create highlight.css")));
}; };
try!(highlight_css.write_all(&theme.highlight_css)); try!(highlight_css.write_all(&theme.highlight_css));
let mut tomorrow_night_css = if let Ok(f) = File::create(book.get_dest().join("tomorrow-night.css")) { f } else { let mut tomorrow_night_css = if let Ok(f) = File::create(book.get_dest().join("tomorrow-night.css")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create tomorrow-night.css"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create tomorrow-night.css")));
}; };
try!(tomorrow_night_css.write_all(&theme.tomorrow_night_css)); try!(tomorrow_night_css.write_all(&theme.tomorrow_night_css));
let mut highlight_js = if let Ok(f) = File::create(book.get_dest().join("highlight.js")) { f } else { let mut highlight_js = if let Ok(f) = File::create(book.get_dest().join("highlight.js")) {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create highlight.js"))) f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create highlight.js")));
}; };
try!(highlight_js.write_all(&theme.highlight_js)); try!(highlight_js.write_all(&theme.highlight_js));
// Font Awesome local fallback // Font Awesome local fallback
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/css/font-awesome.css")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create font-awesome.css"))) .join("_FontAwesome/css/font-awesome.css")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create font-awesome.css")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME)); try!(font_awesome.write_all(theme::FONT_AWESOME));
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/fonts/fontawesome-webfont.eot")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.eot"))) .join("_FontAwesome/fonts/fontawesome-webfon\
t.eot")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.eot")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME_EOT)); try!(font_awesome.write_all(theme::FONT_AWESOME_EOT));
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/fonts/fontawesome-webfont.svg")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.svg"))) .join("_FontAwesome/fonts/fontawesome-webfon\
t.svg")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.svg")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME_SVG)); try!(font_awesome.write_all(theme::FONT_AWESOME_SVG));
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/fonts/fontawesome-webfont.ttf")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.ttf"))) .join("_FontAwesome/fonts/fontawesome-webfon\
t.ttf")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.ttf")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME_TTF)); try!(font_awesome.write_all(theme::FONT_AWESOME_TTF));
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/fonts/fontawesome-webfont.woff")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.woff"))) .join("_FontAwesome/fonts/fontawesome-webfon\
t.woff")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.woff")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME_WOFF)); try!(font_awesome.write_all(theme::FONT_AWESOME_WOFF));
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/fonts/fontawesome-webfont.woff2")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.woff2"))) .join("_FontAwesome/fonts/fontawesome-webfon\
t.woff2")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create fontawesome-webfont.woff2")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME_WOFF2)); try!(font_awesome.write_all(theme::FONT_AWESOME_WOFF2));
let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest().join("_FontAwesome/fonts/FontAwesome.ttf")) { f } else { let mut font_awesome = if let Ok(f) = utils::create_file(&book.get_dest()
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create FontAwesome.ttf"))) .join("_FontAwesome/fonts/FontAwesome.ttf")) {
f
} else {
return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not create FontAwesome.ttf")));
}; };
try!(font_awesome.write_all(theme::FONT_AWESOME_TTF)); try!(font_awesome.write_all(theme::FONT_AWESOME_TTF));
@ -254,7 +301,9 @@ fn make_data(book: &MDBook) -> Result<BTreeMap<String,Json>, Box<Error>> {
BookItem::Affix(ref ch) => { BookItem::Affix(ref ch) => {
chapter.insert("name".to_owned(), ch.name.to_json()); chapter.insert("name".to_owned(), ch.name.to_json());
match ch.path.to_str() { match ch.path.to_str() {
Some(p) => { chapter.insert("path".to_owned(), p.to_json()); }, Some(p) => {
chapter.insert("path".to_owned(), p.to_json());
},
None => return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not convert path to str"))), None => return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not convert path to str"))),
} }
}, },
@ -262,13 +311,15 @@ fn make_data(book: &MDBook) -> Result<BTreeMap<String,Json>, Box<Error>> {
chapter.insert("section".to_owned(), s.to_json()); chapter.insert("section".to_owned(), s.to_json());
chapter.insert("name".to_owned(), ch.name.to_json()); chapter.insert("name".to_owned(), ch.name.to_json());
match ch.path.to_str() { match ch.path.to_str() {
Some(p) => { chapter.insert("path".to_owned(), p.to_json()); }, Some(p) => {
chapter.insert("path".to_owned(), p.to_json());
},
None => return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not convert path to str"))), None => return Err(Box::new(io::Error::new(io::ErrorKind::Other, "Could not convert path to str"))),
} }
}, },
BookItem::Spacer => { BookItem::Spacer => {
chapter.insert("spacer".to_owned(), "_spacer_".to_json()); chapter.insert("spacer".to_owned(), "_spacer_".to_json());
} },
} }

41
src/renderer/html_handlebars/helpers/navigation.rs
View File

@ -55,8 +55,8 @@ pub fn previous(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext
}, },
None => { None => {
debug!("[*]: No title found for chapter"); debug!("[*]: No title found for chapter");
return Err(RenderError{ desc: "No title found for chapter in JSON data".to_owned() }) return Err(RenderError { desc: "No title found for chapter in JSON data".to_owned() });
} },
}; };
// Chapter link // Chapter link
@ -67,11 +67,19 @@ pub fn previous(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext
debug!("[*]: Inserting link: {:?}", path); debug!("[*]: Inserting link: {:?}", path);
match path.to_str() { match path.to_str() {
Some(p) => { previous_chapter.insert("link".to_owned(), p.to_json()); }, Some(p) => {
None => return Err(RenderError{ desc: "Link could not be converted to str".to_owned() }) previous_chapter.insert("link".to_owned(), p.to_json());
},
None => {
return Err(RenderError {
desc: "Link could not be converted to str".to_owned(),
})
},
} }
}, },
None => return Err(RenderError{ desc: "No path found for chapter in JSON data".to_owned() }) None => {
return Err(RenderError { desc: "No path found for chapter in JSON data".to_owned() })
},
} }
debug!("[*]: Inject in context"); debug!("[*]: Inject in context");
@ -84,14 +92,13 @@ pub fn previous(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext
Some(t) => { Some(t) => {
try!(t.render(&updated_context, r, rc)); try!(t.render(&updated_context, r, rc));
}, },
None => return Err(RenderError{ desc: "Error with the handlebars template".to_owned() }) None => return Err(RenderError { desc: "Error with the handlebars template".to_owned() }),
} }
} }
break; break;
} } else {
else {
previous = Some(item.clone()); previous = Some(item.clone());
} }
}, },
@ -140,7 +147,7 @@ pub fn next(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext) ->
let previous_path = match previous.get("path") { let previous_path = match previous.get("path") {
Some(p) => p, Some(p) => p,
None => return Err(RenderError{ desc: "No path found for chapter in JSON data".to_owned() }) None => return Err(RenderError { desc: "No path found for chapter in JSON data".to_owned() }),
}; };
if previous_path == &current { if previous_path == &current {
@ -154,8 +161,10 @@ pub fn next(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext) ->
Some(n) => { Some(n) => {
debug!("[*]: Inserting title: {}", n); debug!("[*]: Inserting title: {}", n);
next_chapter.insert("title".to_owned(), n.to_json()); next_chapter.insert("title".to_owned(), n.to_json());
} },
None => return Err(RenderError{ desc: "No title found for chapter in JSON data".to_owned() }) None => {
return Err(RenderError { desc: "No title found for chapter in JSON data".to_owned() })
},
} }
@ -163,8 +172,10 @@ pub fn next(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext) ->
debug!("[*]: Inserting link: {:?}", link); debug!("[*]: Inserting link: {:?}", link);
match link.to_str() { match link.to_str() {
Some(l) => { next_chapter.insert("link".to_owned(), l.to_json()); }, Some(l) => {
None => return Err(RenderError{ desc: "Link could not converted to str".to_owned() }) next_chapter.insert("link".to_owned(), l.to_json());
},
None => return Err(RenderError { desc: "Link could not converted to str".to_owned() }),
} }
debug!("[*]: Inject in context"); debug!("[*]: Inject in context");
@ -178,10 +189,10 @@ pub fn next(c: &Context, _h: &Helper, r: &Handlebars, rc: &mut RenderContext) ->
Some(t) => { Some(t) => {
try!(t.render(&updated_context, r, rc)); try!(t.render(&updated_context, r, rc));
}, },
None => return Err(RenderError{ desc: "Error with the handlebars template".to_owned() }) None => return Err(RenderError { desc: "Error with the handlebars template".to_owned() }),
} }
break break;
} }
} }

94
src/renderer/html_handlebars/helpers/playpen.rs
View File

@ -17,26 +17,34 @@ pub fn render_playpen(s: &str, path: &Path) -> String {
replaced.push_str(&s[previous_end_index..playpen.start_index - 1]); replaced.push_str(&s[previous_end_index..playpen.start_index - 1]);
replaced.push_str(&s[playpen.start_index..playpen.end_index]); replaced.push_str(&s[playpen.start_index..playpen.end_index]);
previous_end_index = playpen.end_index; previous_end_index = playpen.end_index;
continue continue;
} }
// Check if the file exists // Check if the file exists
if !playpen.rust_file.exists() || !playpen.rust_file.is_file() { if !playpen.rust_file.exists() || !playpen.rust_file.is_file() {
output!("[-] No file exists for {{{{#playpen }}}}\n {}", playpen.rust_file.to_str().unwrap()); output!("[-] No file exists for {{{{#playpen }}}}\n {}", playpen.rust_file.to_str().unwrap());
continue continue;
} }
// Open file & read file // Open file & read file
let mut file = if let Ok(f) = File::open(&playpen.rust_file) { f } else { continue }; let mut file = if let Ok(f) = File::open(&playpen.rust_file) {
f
} else {
continue;
};
let mut file_content = String::new(); let mut file_content = String::new();
if let Err(_) = file.read_to_string(&mut file_content) { continue }; if let Err(_) = file.read_to_string(&mut file_content) {
continue;
};
let replacement = String::new() + "<pre class=\"playpen\"><code class=\"language-rust\">" + &file_content + "</code></pre>"; let replacement = String::new() + "<pre class=\"playpen\"><code class=\"language-rust\">" + &file_content +
"</code></pre>";
replaced.push_str(&s[previous_end_index..playpen.start_index]); replaced.push_str(&s[previous_end_index..playpen.start_index]);
replaced.push_str(&replacement); replaced.push_str(&replacement);
previous_end_index = playpen.end_index; previous_end_index = playpen.end_index;
//println!("Playpen{{ {}, {}, {:?}, {} }}", playpen.start_index, playpen.end_index, playpen.rust_file, playpen.editable); // println!("Playpen{{ {}, {}, {:?}, {} }}", playpen.start_index, playpen.end_index, playpen.rust_file,
// playpen.editable);
} }
replaced.push_str(&s[previous_end_index..]); replaced.push_str(&s[previous_end_index..]);
@ -62,17 +70,27 @@ fn find_playpens(s: &str, base_path: &Path) -> Vec<Playpen> {
if i > 0 { if i > 0 {
if let Some(c) = s[i - 1..].chars().nth(0) { if let Some(c) = s[i - 1..].chars().nth(0) {
if c == '\\' { escaped = true } if c == '\\' {
escaped = true
}
} }
} }
// DON'T forget the "+ i" else you have an index out of bounds error !! // DON'T forget the "+ i" else you have an index out of bounds error !!
let end_i = if let Some(n) = s[i..].find("}}") { n } else { continue } + i + 2; let end_i = if let Some(n) = s[i..].find("}}") {
n
} else {
continue;
} + i + 2;
debug!("s[{}..{}] = {}", i, end_i, s[i..end_i].to_string()); debug!("s[{}..{}] = {}", i, end_i, s[i..end_i].to_string());
// If there is nothing between "{{#playpen" and "}}" skip // If there is nothing between "{{#playpen" and "}}" skip
if end_i-2 - (i+10) < 1 { continue } if end_i - 2 - (i + 10) < 1 {
if s[i+10..end_i-2].trim().len() == 0 { continue } continue;
}
if s[i + 10..end_i - 2].trim().len() == 0 {
continue;
}
debug!("{}", s[i + 10..end_i - 2].to_string()); debug!("{}", s[i + 10..end_i - 2].to_string());
@ -81,18 +99,20 @@ fn find_playpens(s: &str, base_path: &Path) -> Vec<Playpen> {
let mut editable = false; let mut editable = false;
if params.len() > 1 { if params.len() > 1 {
editable = if let Some(_) = params[1].find("editable") {true} else {false}; editable = if let Some(_) = params[1].find("editable") {
true
} else {
false
};
} }
playpens.push( playpens.push(Playpen {
Playpen{
start_index: i, start_index: i,
end_index: end_i, end_index: end_i,
rust_file: base_path.join(PathBuf::from(params[0])), rust_file: base_path.join(PathBuf::from(params[0])),
editable: editable, editable: editable,
escaped: escaped escaped: escaped,
} })
)
} }
playpens playpens
@ -101,7 +121,6 @@ fn find_playpens(s: &str, base_path: &Path) -> Vec<Playpen> {
//
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
// Tests // Tests
// //
@ -130,10 +149,21 @@ fn test_find_playpens_simple_playpen() {
println!("\nOUTPUT: {:?}\n", find_playpens(s, Path::new(""))); println!("\nOUTPUT: {:?}\n", find_playpens(s, Path::new("")));
assert!(find_playpens(s, Path::new("")) == vec![ assert!(find_playpens(s, Path::new("")) ==
Playpen{start_index: 22, end_index: 42, rust_file: PathBuf::from("file.rs"), editable: false, escaped: false}, vec![Playpen {
Playpen{start_index: 47, end_index: 68, rust_file: PathBuf::from("test.rs"), editable: false, escaped: false} start_index: 22,
]); end_index: 42,
rust_file: PathBuf::from("file.rs"),
editable: false,
escaped: false,
},
Playpen {
start_index: 47,
end_index: 68,
rust_file: PathBuf::from("test.rs"),
editable: false,
escaped: false,
}]);
} }
#[test] #[test]
@ -142,10 +172,21 @@ fn test_find_playpens_complex_playpen() {
println!("\nOUTPUT: {:?}\n", find_playpens(s, Path::new("dir"))); println!("\nOUTPUT: {:?}\n", find_playpens(s, Path::new("dir")));
assert!(find_playpens(s, Path::new("dir")) == vec![ assert!(find_playpens(s, Path::new("dir")) ==
Playpen{start_index: 22, end_index: 51, rust_file: PathBuf::from("dir/file.rs"), editable: true, escaped: false}, vec![Playpen {
Playpen{start_index: 56, end_index: 86, rust_file: PathBuf::from("dir/test.rs"), editable: true, escaped: false} start_index: 22,
]); end_index: 51,
rust_file: PathBuf::from("dir/file.rs"),
editable: true,
escaped: false,
},
Playpen {
start_index: 56,
end_index: 86,
rust_file: PathBuf::from("dir/test.rs"),
editable: true,
escaped: false,
}]);
} }
#[test] #[test]
@ -154,7 +195,8 @@ fn test_find_playpens_escaped_playpen() {
println!("\nOUTPUT: {:?}\n", find_playpens(s, Path::new(""))); println!("\nOUTPUT: {:?}\n", find_playpens(s, Path::new("")));
assert!(find_playpens(s, Path::new("")) == vec![ assert!(find_playpens(s, Path::new("")) ==
vec![
Playpen{start_index: 39, end_index: 68, rust_file: PathBuf::from("file.rs"), editable: true, escaped: true}, Playpen{start_index: 39, end_index: 68, rust_file: PathBuf::from("file.rs"), editable: true, escaped: true},
]); ]);
} }

24
src/renderer/html_handlebars/helpers/toc.rs
View File

@ -33,10 +33,14 @@ impl HelperDef for RenderToc {
// Spacer // Spacer
if let Some(_) = item.get("spacer") { if let Some(_) = item.get("spacer") {
try!(rc.writer.write("<li class=\"spacer\"></li>".as_bytes())); try!(rc.writer.write("<li class=\"spacer\"></li>".as_bytes()));
continue continue;
} }
let level = if let Some(s) = item.get("section") { s.len() / 2 } else { 1 }; let level = if let Some(s) = item.get("section") {
s.len() / 2
} else {
1
};
if level > current_level { if level > current_level {
try!(rc.writer.write("<li>".as_bytes())); try!(rc.writer.write("<li>".as_bytes()));
@ -49,8 +53,7 @@ impl HelperDef for RenderToc {
current_level = current_level - 1; current_level = current_level - 1;
} }
try!(rc.writer.write("<li>".as_bytes())); try!(rc.writer.write("<li>".as_bytes()));
} } else {
else {
try!(rc.writer.write("<li".as_bytes())); try!(rc.writer.write("<li".as_bytes()));
if let None = item.get("section") { if let None = item.get("section") {
try!(rc.writer.write(" class=\"affix\"".as_bytes())); try!(rc.writer.write(" class=\"affix\"".as_bytes()));
@ -64,13 +67,12 @@ impl HelperDef for RenderToc {
try!(rc.writer.write("<a href=\"".as_bytes())); try!(rc.writer.write("<a href=\"".as_bytes()));
// Add link // Add link
try!(rc.writer.write( try!(rc.writer.write(Path::new(item.get("path")
Path::new( .expect("Error: path should be Some(_)"))
item.get("path") .with_extension("html")
.expect("Error: path should be Some(_)") .to_str()
).with_extension("html") .unwrap()
.to_str().unwrap().as_bytes() .as_bytes()));
));
try!(rc.writer.write("\"".as_bytes())); try!(rc.writer.write("\"".as_bytes()));

4
src/theme/mod.rs
View File

@ -53,13 +53,13 @@ impl Theme {
// Check if the given path exists // Check if the given path exists
if !src.exists() || !src.is_dir() { if !src.exists() || !src.is_dir() {
return theme return theme;
} }
let src = src.join("theme"); let src = src.join("theme");
// If src does exist, check if there is a theme directory in it // If src does exist, check if there is a theme directory in it
if !src.exists() || !src.is_dir() { if !src.exists() || !src.is_dir() {
return theme return theme;
} }
// Check for individual files if they exist // Check for individual files if they exist

101
src/utils/mod.rs
View File

@ -32,13 +32,16 @@ pub fn path_to_root(path: &Path) -> String {
debug!("[fn]: path_to_root"); debug!("[fn]: path_to_root");
// Remove filename and add "../" for every directory // Remove filename and add "../" for every directory
path.to_path_buf().parent().expect("") path.to_path_buf()
.components().fold(String::new(), |mut s, c| { .parent()
.expect("")
.components()
.fold(String::new(), |mut s, c| {
match c { match c {
Component::Normal(_) => s.push_str("../"), Component::Normal(_) => s.push_str("../"),
_ => { _ => {
debug!("[*]: Other path component... {:?}", c); debug!("[*]: Other path component... {:?}", c);
} },
} }
s s
}) })
@ -64,7 +67,7 @@ pub fn create_file(path: &Path) -> Result<File, Box<Error>> {
Ok(f) => f, Ok(f) => f,
Err(e) => { Err(e) => {
debug!("File::create: {}", e); debug!("File::create: {}", e);
return Err(Box::new(io::Error::new(io::ErrorKind::Other, format!("{}", e)))) return Err(Box::new(io::Error::new(io::ErrorKind::Other, format!("{}", e))));
}, },
}; };
@ -77,7 +80,11 @@ pub fn remove_dir_content(dir: &Path) -> Result<(), Box<Error>> {
for item in try!(fs::read_dir(dir)) { for item in try!(fs::read_dir(dir)) {
if let Ok(item) = item { if let Ok(item) = item {
let item = item.path(); let item = item.path();
if item.is_dir() { try!(fs::remove_dir_all(item)); } else { try!(fs::remove_file(item)); } if item.is_dir() {
try!(fs::remove_dir_all(item));
} else {
try!(fs::remove_file(item));
}
} }
} }
Ok(()) Ok(())
@ -91,7 +98,9 @@ pub fn remove_dir_content(dir: &Path) -> Result<(), Box<Error>> {
pub fn copy_files_except_ext(from: &Path, to: &Path, recursive: bool, ext_blacklist: &[&str]) -> Result<(), Box<Error>> { pub fn copy_files_except_ext(from: &Path, to: &Path, recursive: bool, ext_blacklist: &[&str]) -> Result<(), Box<Error>> {
debug!("[fn] copy_files_except_ext"); debug!("[fn] copy_files_except_ext");
// Check that from and to are different // Check that from and to are different
if from == to { return Ok(()) } if from == to {
return Ok(());
}
debug!("[*] Loop"); debug!("[*] Loop");
for entry in try!(fs::read_dir(from)) { for entry in try!(fs::read_dir(from)) {
let entry = try!(entry); let entry = try!(entry);
@ -100,7 +109,9 @@ pub fn copy_files_except_ext(from: &Path, to: &Path, recursive: bool, ext_blackl
// If the entry is a dir and the recursive option is enabled, call itself // If the entry is a dir and the recursive option is enabled, call itself
if metadata.is_dir() && recursive { if metadata.is_dir() && recursive {
if entry.path() == to.to_path_buf() { continue } if entry.path() == to.to_path_buf() {
continue;
}
debug!("[*] is dir"); debug!("[*] is dir");
// check if output dir already exists // check if output dir already exists
@ -108,21 +119,25 @@ pub fn copy_files_except_ext(from: &Path, to: &Path, recursive: bool, ext_blackl
try!(fs::create_dir(&to.join(entry.file_name()))); try!(fs::create_dir(&to.join(entry.file_name())));
} }
try!(copy_files_except_ext( try!(copy_files_except_ext(&from.join(entry.file_name()),
&from.join(entry.file_name()),
&to.join(entry.file_name()), &to.join(entry.file_name()),
true, true,
ext_blacklist ext_blacklist));
));
} else if metadata.is_file() { } else if metadata.is_file() {
// Check if it is in the blacklist // Check if it is in the blacklist
if let Some(ext) = entry.path().extension() { if let Some(ext) = entry.path().extension() {
if ext_blacklist.contains(&ext.to_str().unwrap()) { continue } if ext_blacklist.contains(&ext.to_str().unwrap()) {
debug!("[*] creating path for file: {:?}", &to.join(entry.path().file_name().expect("a file should have a file name..."))); continue;
}
debug!("[*] creating path for file: {:?}",
&to.join(entry.path().file_name().expect("a file should have a file name...")));
output!("[*] copying file: {:?}\n to {:?}", entry.path(), &to.join(entry.path().file_name().expect("a file should have a file name..."))); output!("[*] copying file: {:?}\n to {:?}",
try!(fs::copy(entry.path(), &to.join(entry.path().file_name().expect("a file should have a file name...")))); entry.path(),
&to.join(entry.path().file_name().expect("a file should have a file name...")));
try!(fs::copy(entry.path(),
&to.join(entry.path().file_name().expect("a file should have a file name..."))));
} }
} }
} }
@ -168,17 +183,35 @@ mod tests {
}; };
// Create a couple of files // Create a couple of files
if let Err(_) = fs::File::create(&tmp.path().join("file.txt")) { panic!("Could not create file.txt") } if let Err(_) = fs::File::create(&tmp.path().join("file.txt")) {
if let Err(_) = fs::File::create(&tmp.path().join("file.md")) { panic!("Could not create file.md") } panic!("Could not create file.txt")
if let Err(_) = fs::File::create(&tmp.path().join("file.png")) { panic!("Could not create file.png") } }
if let Err(_) = fs::create_dir(&tmp.path().join("sub_dir")) { panic!("Could not create sub_dir") } if let Err(_) = fs::File::create(&tmp.path().join("file.md")) {
if let Err(_) = fs::File::create(&tmp.path().join("sub_dir/file.png")) { panic!("Could not create sub_dir/file.png") } panic!("Could not create file.md")
if let Err(_) = fs::create_dir(&tmp.path().join("sub_dir_exists")) { panic!("Could not create sub_dir_exists") } }
if let Err(_) = fs::File::create(&tmp.path().join("sub_dir_exists/file.txt")) { panic!("Could not create sub_dir_exists/file.txt") } if let Err(_) = fs::File::create(&tmp.path().join("file.png")) {
panic!("Could not create file.png")
}
if let Err(_) = fs::create_dir(&tmp.path().join("sub_dir")) {
panic!("Could not create sub_dir")
}
if let Err(_) = fs::File::create(&tmp.path().join("sub_dir/file.png")) {
panic!("Could not create sub_dir/file.png")
}
if let Err(_) = fs::create_dir(&tmp.path().join("sub_dir_exists")) {
panic!("Could not create sub_dir_exists")
}
if let Err(_) = fs::File::create(&tmp.path().join("sub_dir_exists/file.txt")) {
panic!("Could not create sub_dir_exists/file.txt")
}
// Create output dir // Create output dir
if let Err(_) = fs::create_dir(&tmp.path().join("output")) { panic!("Could not create output") } if let Err(_) = fs::create_dir(&tmp.path().join("output")) {
if let Err(_) = fs::create_dir(&tmp.path().join("output/sub_dir_exists")) { panic!("Could not create output/sub_dir_exists") } panic!("Could not create output")
}
if let Err(_) = fs::create_dir(&tmp.path().join("output/sub_dir_exists")) {
panic!("Could not create output/sub_dir_exists")
}
match copy_files_except_ext(&tmp.path(), &tmp.path().join("output"), true, &["md"]) { match copy_files_except_ext(&tmp.path(), &tmp.path().join("output"), true, &["md"]) {
Err(e) => panic!("Error while executing the function:\n{:?}", e), Err(e) => panic!("Error while executing the function:\n{:?}", e),
@ -186,11 +219,21 @@ mod tests {
} }
// Check if the correct files where created // Check if the correct files where created
if !(&tmp.path().join("output/file.txt")).exists() { panic!("output/file.txt should exist") } if !(&tmp.path().join("output/file.txt")).exists() {
if (&tmp.path().join("output/file.md")).exists() { panic!("output/file.md should not exist") } panic!("output/file.txt should exist")
if !(&tmp.path().join("output/file.png")).exists() { panic!("output/file.png should exist") } }
if !(&tmp.path().join("output/sub_dir/file.png")).exists() { panic!("output/sub_dir/file.png should exist") } if (&tmp.path().join("output/file.md")).exists() {
if !(&tmp.path().join("output/sub_dir_exists/file.txt")).exists() { panic!("output/sub_dir/file.png should exist") } panic!("output/file.md should not exist")
}
if !(&tmp.path().join("output/file.png")).exists() {
panic!("output/file.png should exist")
}
if !(&tmp.path().join("output/sub_dir/file.png")).exists() {
panic!("output/sub_dir/file.png should exist")
}
if !(&tmp.path().join("output/sub_dir_exists/file.txt")).exists() {
panic!("output/sub_dir/file.png should exist")
}
} }
} }