mirror/ crowbook
1
0
Fork 0
mirror of https://github.com/lise-henry/crowbook synced 2024-06-10 02:06:22 +02:00
Code Issues

Remove dead code

This commit is contained in:
Elisabeth Henry 2017-10-04 14:26:15 +02:00
parent 63fe7b2a6f
commit f2df59ab6b
15 changed files with 48 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/helpers.rs
View File

@ -1,5 +1,5 @@
use crowbook::Book;
use clap::{App, Arg, Format, ArgMatches, AppSettings};
use clap::{App, Arg, ArgMatches, AppSettings};
use std::io::{self, Write};
use std::process::exit;

4
src/bin/real_main.rs
View File

@ -19,14 +19,14 @@ extern crate clap;
use helpers::*;
use crowbook::{Result, Book, BookOptions, InfoLevel};
use crowbook::{Result, Book, BookOptions};
use crowbook_intl_runtime::set_lang;
use crowbook::Stats;
use clap::ArgMatches;
use std::process::exit;
use std::io;
use std::env;
use simplelog::{Config, TermLogger, CombinedLogger, LogLevel, LogLevelFilter, SimpleLogger, SharedLogger};
use simplelog::{Config, TermLogger, LogLevel, LogLevelFilter, SimpleLogger};
/// Render a book to specific format
fn render_format(book: &mut Book, matches: &ArgMatches, format: &str) -> ! {

76
src/lib/book.rs
View File

@ -29,7 +29,6 @@ use odt::{Odt};
use templates::{epub, html, epub3, latex, html_dir, highlight, html_single, html_if};
use number::Number;
use resource_handler::ResourceHandler;
use logger::{Logger, InfoLevel};
use lang;
use misc;
use book_renderer::BookRenderer;
@ -156,10 +155,6 @@ pub struct Book {
#[doc(hidden)]
pub root: PathBuf,
/// Logger
#[doc(hidden)]
pub logger: Logger,
/// Source for error files
#[doc(hidden)]
pub source: Source,
@ -186,7 +181,6 @@ impl Book {
cleaner: Box::new(Off),
root: PathBuf::new(),
options: BookOptions::new(),
logger: Logger::new(),
chapter_template: None,
part_template: None,
checker: None,
@ -270,22 +264,6 @@ impl Book {
self
}
/// Sets the verbosity of a book
///
/// See `InfoLevel` for more information on verbosity
///
/// # Example
///
/// ```
/// use crowbook::{Book, InfoLevel};
/// let mut book = Book::new();
/// book.set_verbosity(InfoLevel::Warning);
/// ```
pub fn set_verbosity(&mut self, verbosity: InfoLevel) -> &mut Book {
self.logger.set_verbosity(verbosity);
self
}
/// Loads a book configuration file
///
/// # Argument
@ -679,8 +657,7 @@ impl Book {
match checker {
Ok(checker) => self.checker = Some(checker),
Err(e) => {
self.logger
.error(lformat!("{error}. Proceeding without using languagetool.", error = e))
error!("{}", lformat!("{error}. Proceeding without using languagetool.", error = e))
}
}
}
@ -691,8 +668,7 @@ impl Book {
match checker {
Ok(checker) => self.grammalecte = Some(checker),
Err(e) => {
self.logger
.error(lformat!("{error}. Proceeding without using grammalecte.", error = e))
error!("{}", lformat!("{error}. Proceeding without using grammalecte.", error = e))
}
}
}
@ -722,8 +698,7 @@ impl Book {
if let Ok(path) = self.options.get_path(&key) {
let result = self.render_format_to_file(format, path);
if let Err(err) = result {
self.logger
.error(lformat!("Error rendering {name}: {error}", name = format, error = err));
error!("{}", lformat!("Error rendering {name}: {error}", name = format, error = err));
}
}
}
@ -1306,29 +1281,26 @@ impl Book {
.set_yaml(key.clone(), value.clone()) {
Ok(opt) => {
if let Some(old_value) = opt {
self.logger
.debug(lformat!("Inline YAML block \
replaced {:?} \
previously set to \
debug!("{}", lformat!("Inline YAML block \
replaced {:?} \
previously set to \
{:?} to {:?}",
key,
old_value,
value));
key,
old_value,
value));
} else {
self.logger
.debug(lformat!("Inline YAML block \
set {:?} to {:?}",
key,
value));
debug!("{}", lformat!("Inline YAML block \
set {:?} to {:?}",
key,
value));
}
}
Err(e) => {
self.logger
.error(lformat!("Inline YAML block could \
not set {:?} to {:?}: {}",
key,
value,
e))
error!("{}", lformat!("Inline YAML block could \
not set {:?} to {:?}: {}",
key,
value,
e))
}
}
}
@ -1340,15 +1312,13 @@ impl Book {
valid_block = true;
}
Err(err) => {
self.logger
.error(lformat!("Found something that looked like a \
error!("{}", lformat!("Found something that looked like a \
YAML block:\n{block}",
block = &yaml_block));
self.logger
.error(lformat!("... but it didn't parse correctly as \
YAML('{error}'), so treating it like \
Markdown.",
error = err));
error!("{}", lformat!("... but it didn't parse correctly as \
YAML('{error}'), so treating it like \
Markdown.",
error = err));
}
}
break;

1
src/lib/bookoptions.rs
View File

@ -1,7 +1,6 @@
use error::{Error, Result, Source};
use bookoption::BookOption;
use book::Book;
use logger::{Logger};
use yaml_rust::{Yaml, YamlLoader};
use std::collections::HashMap;

1
src/lib/grammalecte.rs
View File

@ -28,7 +28,6 @@ use text_view::insert_annotation;
use token::Token;
use token::Data;
use error::{Error, Result, Source};
use logger::Logger;
/// Represents a grammar error from Grammalecte
///

7
src/lib/html.rs
View File

@ -26,7 +26,6 @@ use resource_handler::ResourceHandler;
use renderer::Renderer;
use parser::Parser;
use syntax::Syntax;
use logger::Logger;
use lang;
use std::borrow::Cow;
@ -87,7 +86,7 @@ pub struct HtmlRenderer<'a> {
/// Resource handler
#[doc(hidden)]
pub handler: ResourceHandler<'a>,
pub handler: ResourceHandler,
/// Current footnote number
#[doc(hidden)]
@ -120,7 +119,7 @@ impl<'a> HtmlRenderer<'a> {
"syntect" => {
// Don't init syntect if codeblocks are not used
if book.features.codeblock {
(Highlight::Syntect, Some(Syntax::new(book, theme)))
(Highlight::Syntect, Some(Syntax::new(theme)))
} else {
(Highlight::None, None)
}
@ -153,7 +152,7 @@ impl<'a> HtmlRenderer<'a> {
footnotes: vec![],
verbatim: false,
filename: String::new(),
handler: ResourceHandler::new(&book.logger),
handler: ResourceHandler::new(),
source: Source::empty(),
first_letter: false,
first_paragraph: true,

14
src/lib/latex.rs
View File

@ -42,7 +42,7 @@ use std::borrow::Cow;
pub struct LatexRenderer<'a> {
book: &'a Book,
current_chapter: Number,
handler: ResourceHandler<'a>,
handler: ResourceHandler,
source: Source,
escape: bool,
first_letter: bool,
@ -57,14 +57,13 @@ pub struct LatexRenderer<'a> {
impl<'a> LatexRenderer<'a> {
/// Creates new LatexRenderer
pub fn new(book: &'a Book) -> LatexRenderer<'a> {
let mut handler = ResourceHandler::new(&book.logger);
let mut handler = ResourceHandler::new();
handler.set_images_mapping(true);
let syntax = if book.options.get_str("rendering.highlight").unwrap() == "syntect"
&& book.features.codeblock {
Some(Syntax::new(book,
book.options
.get_str("tex.highlight.theme")
.unwrap_or_else(|_| book.options.get_str("rendering.highlight.theme").unwrap())))
Some(Syntax::new(book.options
.get_str("tex.highlight.theme")
.unwrap_or_else(|_| book.options.get_str("rendering.highlight.theme").unwrap())))
} else {
None
};
@ -95,8 +94,7 @@ impl<'a> LatexRenderer<'a> {
pub fn render_pdf(&mut self, to: &mut io::Write) -> Result<String> {
let content = self.render_book()?;
let mut zipper = Zipper::new(&self.book.options.get_path("crowbook.temp_dir")
.unwrap(),
&self.book.logger)?;
.unwrap())?;
zipper.write("result.tex", content.as_bytes(), false)?;
// write image files

2
src/lib/lib.rs
View File

@ -141,7 +141,6 @@ pub use token::Token;
pub use token::Data;
pub use number::Number;
pub use resource_handler::ResourceHandler;
pub use logger::{Logger, InfoLevel};
pub use renderer::Renderer;
pub use book_renderer::BookRenderer;
pub use chapter::Chapter;
@ -164,7 +163,6 @@ mod cleaner;
mod chapter;
mod number;
mod resource_handler;
mod logger;
mod bookoptions;
mod lang;
mod renderer;

188
src/lib/logger.rs
View File

@ -1,188 +0,0 @@
use term;
use std::convert::AsRef;
use std::io;
use std::io::Write;
use std::fmt::Display;
/// The level of information to display to a logger
///
/// This enum should only be used as parameters for `Logger` or `Book` methods. Library
/// users should **not** do exhaustive pattern matching on the variants of the enums,
/// as it might grow variants later.
#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]
pub enum InfoLevel {
/// Debug: the lowest level
Debug = 0,
/// Warning: will be displayed by default
Warning,
/// Info: will be displayed by default
Info,
/// Error
Error,
/// Quiet
Quiet,
/// Hint that destructuring should not be exhaustive
#[doc(hidden)]
__NonExhaustive,
}
use self::InfoLevel::*;
/// Abstract over either term output or (if it fails) io::stderr()
enum Output {
Terminal(Box<term::StderrTerminal>),
Stderr(io::Stderr),
}
impl Output {
/// Creates a new Output
pub fn new() -> Output {
if let Some(term) = term::stderr() {
if (*term).supports_color() {
return Output::Terminal(term)
}
}
Output::Stderr(io::stderr())
}
/// Print a msg prefixed by a coloured `level` message
pub fn print_msg<S: Display>(&mut self, level: InfoLevel, msg: S) {
let (colour, head_msg) = match level {
Debug => (term::color::BRIGHT_BLUE, lformat!("Debug: ")),
Warning => (term::color::BRIGHT_YELLOW, lformat!("Warning: ")),
Info => (term::color::BRIGHT_GREEN, lformat!("Info: ")),
Error => (term::color::BRIGHT_RED, lformat!("Error: ")),
_ => unreachable!(),
};
match *self {
Output::Stderr(ref mut stderr) => {
writeln!(stderr, "{}{}",
head_msg,
msg)
.unwrap();
},
Output::Terminal(ref mut term) => {
let _ = term.fg(colour);
let _ = term.attr(term::Attr::Bold);
write!(term, "{}",
head_msg)
.unwrap();
let _ = term.reset();
writeln!(term, "{}",
msg)
.unwrap();
}
}
}
}
/// Logs info and warning message and choose whether to display them
/// according to verbosity.
///
/// This struct has two families of methods:
///
/// * `logger.{level}`: will only print the message if `level` is below or equal
/// `logger`'s current verbosity level;
/// * `Logger::display_{level}`: will print the message in any case, since they are static
/// methods and don't depend on the current verbosity.
///
/// # Example
///
/// ```
/// use crowbook::{Logger, InfoLevel};
/// let mut logger = Logger::new();
/// logger.warning("Won't be printed since default level is above that");
/// logger.set_verbosity(InfoLevel::Warning);
/// logger.warning("Now, this will be printed");
/// Logger::display_debug("Display in any cases");
/// ```
///
/// # See also
/// * `InfoLevel`
#[derive(Debug)]
pub struct Logger {
verbosity: InfoLevel,
}
impl Logger {
/// Creates a new logger with default verbosity (`Info`).
pub fn new() -> Logger {
Logger { verbosity: InfoLevel::Warning }
}
/// Get verbosity
pub fn verbosity(&self) -> InfoLevel {
self.verbosity
}
/// Sets verbosity
pub fn set_verbosity(&mut self, verbosity: InfoLevel) -> &mut Logger {
self.verbosity = verbosity;
self
}
/// Prints a message
pub fn display_msg<S: AsRef<str>>(level: InfoLevel, s: S) {
let mut output = Output::new();
output.print_msg(level, s.as_ref());
}
/// Prints a debug message
pub fn display_debug<S: AsRef<str>>(s: S) {
Self::display_msg(Debug, s);
}
/// Prints an info message
pub fn display_info<S: AsRef<str>>(s: S) {
Self::display_msg(Info, s);
}
/// Prints a warning message
pub fn display_warning<S: AsRef<str>>(s: S) {
Self::display_msg(Warning, s);
}
/// Prints an error message
pub fn display_error<S: AsRef<str>>(s: S) {
Self::display_msg(Error, s);
}
/// Prints a message if logger's verbosity <= level
pub fn log<S: AsRef<str>>(&self, level: InfoLevel, s: S) {
if level >= self.verbosity {
match level {
Debug => Self::display_debug(s),
Info => Self::display_info(s),
Warning => Self::display_warning(s),
Error => Self::display_error(s),
Quiet => unreachable!(),
__NonExhaustive => unreachable!(),
}
}
}
/// Equivalent of log(Debug, s)
pub fn debug<S: AsRef<str>>(&self, s: S) {
self.log(InfoLevel::Debug, s);
}
/// Equivalent of log(Info, s)
pub fn info<S: AsRef<str>>(&self, s: S) {
self.log(InfoLevel::Info, s);
}
/// Equivalent of log(Warning, s)
pub fn warning<S: AsRef<str>>(&self, s: S) {
self.log(InfoLevel::Warning, s);
}
/// Equivalent of log(Error, s)
pub fn error<S: AsRef<str>>(&self, s: S) {
self.log(InfoLevel::Error, s);
}
}

3
src/lib/odt.rs
View File

@ -62,8 +62,7 @@ impl<'a> OdtRenderer<'a> {
let content = self.render_content()?;
let mut zipper =
Zipper::new(&self.book.options.get_path("crowbook.temp_dir").unwrap(),
&self.book.logger)?;
Zipper::new(&self.book.options.get_path("crowbook.temp_dir").unwrap())?;
// Write template.odt there
zipper.write("template.odt", odt::ODT, false)?;

1
src/lib/parser.rs
View File

@ -17,7 +17,6 @@
use token::Token;
use error::{Result, Error, Source};
use logger::Logger;
use book::Book;
use std::mem;

9
src/lib/resource_handler.rs
View File

@ -1,5 +1,4 @@
use token::Token;
use logger::Logger;
use error::{Error, Result, Source};
use std::collections::HashMap;
@ -17,12 +16,11 @@ use mime_guess;
/// Its task is to make sure that some resource (image, link) is available
/// for the book and to list images used in Markdown files so they can be used for the book
#[derive(Debug)]
pub struct ResourceHandler<'r> {
pub struct ResourceHandler {
/// Maps an original url (e.g.) "foo/Readme.md" to a valid link
/// (e.g.) chapter3.html
links: HashMap<String, String>,
map_images: bool,
logger: &'r Logger,
base64: bool,
/// Maps an original (local) file name to a new file name. Allows to
@ -31,15 +29,14 @@ pub struct ResourceHandler<'r> {
pub images: HashMap<String, String>,
}
impl<'r> ResourceHandler<'r> {
impl ResourceHandler {
/// Creates a new, empty Resource Handler
pub fn new(logger: &'r Logger) -> ResourceHandler {
pub fn new() -> ResourceHandler {
ResourceHandler {
links: HashMap::new(),
images: HashMap::new(),
map_images: false,
base64: false,
logger: logger,
}
}

5
src/lib/syntax.rs
View File

@ -16,7 +16,6 @@
// along with Crowbook. If not, see <http://www.gnu.org/licenses/>.
use error::Result;
use book::Book;
use crowbook_text_processing::escape;
@ -37,7 +36,7 @@ pub struct Syntax {}
#[cfg(feature="syntect")]
impl Syntax {
/// Creates a new Syntax wrapper
pub fn new(book: &Book, theme_name: &str) -> Syntax {
pub fn new(theme_name: &str) -> Syntax {
let mut theme_set = syntect::highlighting::ThemeSet::load_defaults();
let theme = match theme_set.themes.remove(theme_name) {
Some(theme) => theme,
@ -127,7 +126,7 @@ fn strip_language(language: &str) -> &str {
#[cfg(not(feature="syntect"))]
impl Syntax {
pub fn new(book: &Book, _: &str) -> Syntax {
pub fn new( _: &str) -> Syntax {
error!("{}", lformat!("crowbook was compiled without syntect support, syntax highlighting will be disabled"));
Syntax {}
}

1
src/lib/text_view.rs
View File

@ -20,7 +20,6 @@ use std::default::Default;
use token::Token;
use token::Data;
use logger::Logger;
pub fn traverse_token<F1, F2, R>(token: &Token, f: &F1, add: &F2) -> R
where F1: Fn(&str) -> R,

16
src/lib/zipper.rs
View File

@ -16,7 +16,7 @@
// along with Crowbook. If not, see <http://www.gnu.org/licenses/>.
use error::{Error, Result};
use logger::{Logger, InfoLevel};
use log::LogLevel::Debug;
use std::path::{Path, PathBuf};
use std::io;
@ -27,19 +27,18 @@ use uuid;
use std::ops::Drop;
/// Struct used to create zip (using filesystem and zip command)
pub struct Zipper<'a> {
pub struct Zipper {
args: Vec<String>,
path: PathBuf,
logger: &'a Logger,
}
impl<'a> Zipper<'a> {
impl Zipper {
/// Creates new zipper
///
/// # Arguments
/// * `path`: the path to a temporary directory
/// (zipper will create a random dir in it and clean it later)
pub fn new(path: &str, logger: &'a Logger) -> Result<Zipper<'a>> {
pub fn new(path: &str) -> Result<Zipper> {
let uuid = uuid::Uuid::new_v4();
let zipper_path = Path::new(path).join(uuid.simple().to_string());
@ -54,7 +53,6 @@ impl<'a> Zipper<'a> {
Ok(Zipper {
args: vec![],
path: zipper_path,
logger: logger,
})
}
@ -127,7 +125,7 @@ This is forbidden because we are supposed \
.current_dir(&self.path)
.output()
.map_err(|e| {
if self.logger.verbosity() <= InfoLevel::Warning {
if log_enabled!(Debug) {
Error::zipper(lformat!("failed to run command '{name}'.\n\
Command output: \n\
{error}",
@ -142,7 +140,7 @@ This is forbidden because we are supposed \
if output.status.success() {
let mut file = File::open(self.path.join(in_file))
.map_err(|_| {
if self.logger.verbosity() <= InfoLevel::Warning {
if log_enabled!(Debug) {
Error::zipper(lformat!("could not open result of command '{command}'\n\
Command output:\n\
{output}'",
@ -193,7 +191,7 @@ This is forbidden because we are supposed \
}
}
impl<'a> Drop for Zipper<'a> {
impl Drop for Zipper {
fn drop(&mut self) {
if let Err(err) = fs::remove_dir_all(&self.path) {
println!("Error in zipper: could not delete temporary directory {}, error: {}",