bat/src/controller.rs

120 lines
3.8 KiB
Rust
Raw Normal View History

use std::io::{self, Write};
use std::path::Path;
2018-08-23 22:37:27 +02:00
use app::{Config, PagingMode};
2018-08-23 22:37:27 +02:00
use assets::HighlightingAssets;
use errors::*;
use inputfile::{InputFile, InputFileReader};
2018-10-20 00:10:10 +02:00
use line_range::{LineRanges, RangeCheckResult};
2018-08-23 22:37:27 +02:00
use output::OutputType;
use printer::{InteractivePrinter, Printer, SimplePrinter};
2018-08-23 22:37:27 +02:00
pub struct Controller<'a> {
config: &'a Config<'a>,
assets: &'a HighlightingAssets,
}
impl<'b> Controller<'b> {
pub fn new<'a>(config: &'a Config, assets: &'a HighlightingAssets) -> Controller<'a> {
Controller { config, assets }
}
pub fn run(&self) -> Result<bool> {
// Do not launch the pager if NONE of the input files exist
let mut paging_mode = self.config.paging_mode;
if self.config.paging_mode != PagingMode::Never {
let call_pager = self.config.files.iter().any(|file| {
if let InputFile::Ordinary(path) = file {
return Path::new(path).exists();
} else {
return true;
}
});
if !call_pager {
paging_mode = PagingMode::Never;
}
}
let mut output_type = OutputType::from_mode(paging_mode, self.config.pager)?;
2018-08-23 22:37:27 +02:00
let writer = output_type.handle()?;
let mut no_errors: bool = true;
let stdin = io::stdin();
2018-10-07 11:54:01 +02:00
for input_file in &self.config.files {
match input_file.get_reader(&stdin) {
Err(error) => {
handle_error(&error);
no_errors = false;
}
Ok(mut reader) => {
let result = if self.config.loop_through {
let mut printer = SimplePrinter::new();
self.print_file(reader, &mut printer, writer, *input_file)
} else {
let mut printer = InteractivePrinter::new(
&self.config,
&self.assets,
*input_file,
&mut reader,
);
self.print_file(reader, &mut printer, writer, *input_file)
};
if let Err(error) = result {
handle_error(&error);
no_errors = false;
}
}
2018-08-23 22:37:27 +02:00
}
}
Ok(no_errors)
}
2018-08-28 20:12:45 +02:00
fn print_file<'a, P: Printer>(
&self,
reader: InputFileReader,
printer: &mut P,
writer: &mut Write,
2018-10-07 11:54:01 +02:00
input_file: InputFile<'a>,
) -> Result<()> {
2018-10-07 11:54:01 +02:00
printer.print_header(writer, input_file)?;
2018-11-01 20:29:48 +01:00
self.print_file_ranges(printer, writer, reader, &self.config.line_ranges)?;
2018-10-07 11:54:01 +02:00
printer.print_footer(writer)?;
2018-08-23 22:37:27 +02:00
Ok(())
}
fn print_file_ranges<'a, P: Printer>(
&self,
printer: &mut P,
writer: &mut Write,
mut reader: InputFileReader,
2018-10-20 00:10:10 +02:00
line_ranges: &LineRanges,
2018-08-23 22:37:27 +02:00
) -> Result<()> {
let mut line_buffer = Vec::new();
2018-08-23 22:37:27 +02:00
let mut line_number: usize = 1;
while reader.read_line(&mut line_buffer)? {
2018-10-20 00:10:10 +02:00
match line_ranges.check(line_number) {
RangeCheckResult::OutsideRange => {
// Call the printer in case we need to call the syntax highlighter
// for this line. However, set `out_of_range` to `true`.
printer.print_line(true, writer, line_number, &line_buffer)?;
2018-08-23 22:37:27 +02:00
}
2018-10-20 00:10:10 +02:00
RangeCheckResult::InRange => {
2018-10-07 10:09:10 +02:00
printer.print_line(false, writer, line_number, &line_buffer)?;
}
2018-10-20 00:10:10 +02:00
RangeCheckResult::AfterLastRange => {
break;
}
2018-08-23 22:37:27 +02:00
}
2018-10-07 10:09:10 +02:00
line_number += 1;
line_buffer.clear();
2018-08-23 22:37:27 +02:00
}
Ok(())
}
}