#![crate_name = "shell"]
extern crate term;
extern crate libc;
use std::fmt;
use std::fmt::Display;
use std::io::prelude::*;
use std::io;
use std::error::Error;
use term::Attr;
use term::color::{Color, BLACK, RED, GREEN, YELLOW, BRIGHT_YELLOW, BRIGHT_RED};
use term::{Terminal, TerminfoTerminal, color};
use self::AdequateTerminal::{NoColor, Colored};
static GREY: u16 = 8;
#[derive(Clone, Copy)]
pub struct ShellConfig {
pub color: bool,
pub verbose: bool,
pub tty: bool
}
enum AdequateTerminal {
NoColor(Box<Write + Send>),
Colored(Box<Terminal<Output=Box<Write + Send>> + Send>)
}
pub struct Shell {
terminal: AdequateTerminal,
config: ShellConfig,
}
pub struct MultiShell {
out: Shell,
err: Shell,
verbose: bool
}
#[cfg(unix)]
fn isatty(fd: libc::c_int) -> bool {
unsafe { libc::isatty(fd) != 0 }
}
#[cfg(windows)]
fn isatty(fd: libc::c_int) -> bool {
extern crate kernel32;
extern crate winapi;
unsafe {
let handle = kernel32::GetStdHandle(
if fd == libc::STDOUT_FILENO {
winapi::winbase::STD_OUTPUT_HANDLE
} else {
winapi::winbase::STD_ERROR_HANDLE
});
let mut out = 0;
kernel32::GetConsoleMode(handle, &mut out) != 0
}
}
impl MultiShell {
pub fn new_stdio(verbose: bool) -> MultiShell {
let tty = isatty(libc::STDERR_FILENO);
let stderr = Box::new(io::stderr()) as Box<Write + Send>;
let config = ShellConfig { color: true, verbose: verbose, tty: tty };
let err = Shell::create(stderr, config);
let tty = isatty(libc::STDOUT_FILENO);
let stdout = Box::new(io::stdout()) as Box<Write + Send>;
let config = ShellConfig { color: true, verbose: verbose, tty: tty };
let out = Shell::create(stdout, config);
MultiShell::new(out, err, verbose)
}
pub fn new(out: Shell, err: Shell, verbose: bool) -> MultiShell {
MultiShell { out: out, err: err, verbose: verbose }
}
pub fn out(&mut self) -> &mut Shell {
&mut self.out
}
pub fn err(&mut self) -> &mut Shell {
&mut self.err
}
pub fn say<T: ToString>(&mut self, message: T, color: Color) -> io::Result<()> {
self.out().say(message, color)
}
pub fn status<T, U>(&mut self, status: T, message: U) -> io::Result<()>
where T: fmt::Display, U: fmt::Display
{
self.out().say_status(status, message, GREEN)
}
pub fn verbose<F>(&mut self, mut callback: F) -> io::Result<()>
where F: FnMut(&mut MultiShell) -> io::Result<()>
{
if self.verbose { return callback(self) }
Ok(())
}
pub fn concise<F>(&mut self, mut callback: F) -> io::Result<()>
where F: FnMut(&mut MultiShell) -> io::Result<()>
{
if !self.verbose { return callback(self) }
Ok(())
}
pub fn error<T: ToString>(&mut self, message: T) -> io::Result<()> {
self.err().say(message, RED)
}
pub fn warn<T: ToString>(&mut self, message: T) -> io::Result<()> {
self.err().say(message, YELLOW)
}
pub fn set_verbose(&mut self, verbose: bool) {
self.verbose = verbose;
}
pub fn get_verbose(&self) -> bool {
self.verbose
}
pub fn tag<T: Display, U: Display>(&mut self, tag: T, message: U) -> io::Result<()>{
self.out().say_status(tag, message, BLACK)
}
pub fn header<T: Display>(&mut self, message: T) -> io::Result<()> {
self.out().say_attr(message, BLACK, Attr::Underline(true), true)
}
pub fn comment<T: Display>(&mut self, message: T) -> io::Result<()> {
self.out().say_attr(message, GREY, Attr::Dim, true)
}
pub fn tag_color<T: Display, U: Display>(&mut self, tag: T, message: U, color: Color) -> io::Result<()>{
self.out().say_status(tag, message, color)
}
pub fn error_full(&mut self, e: &Error, mut show_cause: bool) -> io::Result<()>{
try!(self.err().say_write( "error: ", BRIGHT_RED));
try!(self.err().say_attr(format!("{}", e.description()), BLACK, Attr::Bold, true));
let mut e = e;
while show_cause {
if e.cause().is_some() {
e = e.cause().unwrap();
try!(self.err().say_write( "caused by: ", BRIGHT_YELLOW));
try!(self.err().say(format!("{}", e.description()), BLACK));
} else { show_cause = false; }
}
Ok(())
}
}
impl Shell {
pub fn create(out: Box<Write + Send>, config: ShellConfig) -> Shell {
if config.tty && config.color {
let term = TerminfoTerminal::new(out);
term.map(|t| Shell {
terminal: Colored(Box::new(t)),
config: config
}).unwrap_or_else(|| {
Shell { terminal: NoColor(Box::new(io::stderr())), config: config }
})
} else {
Shell { terminal: NoColor(out), config: config }
}
}
pub fn verbose<F>(&mut self, mut callback: F) -> io::Result<()>
where F: FnMut(&mut Shell) -> io::Result<()>
{
if self.config.verbose { return callback(self) }
Ok(())
}
pub fn concise<F>(&mut self, mut callback: F) -> io::Result<()>
where F: FnMut(&mut Shell) -> io::Result<()>
{
if !self.config.verbose { return callback(self) }
Ok(())
}
pub fn say_write<T: Display>(&mut self, message: T, color: Color) -> io::Result<()> {
try!(self.reset());
if color != BLACK { try!(self.fg(color)); }
try!(write!(self, "{}", message));
try!(self.reset());
try!(self.flush());
Ok(())
}
pub fn say_attr<T: Display>(&mut self, message: T, color: Color, attr: Attr, new_line: bool) -> io::Result<()> {
try!(self.reset());
try!(self.attr(attr));
if color != BLACK { try!(self.fg(color)); }
if new_line {
try!(write!(self, "{}\n", message));
} else {
try!(write!(self, "{}", message));
}
try!(self.reset());
try!(self.flush());
Ok(())
}
pub fn say<T: ToString>(&mut self, message: T, color: Color) -> io::Result<()> {
try!(self.reset());
if color != BLACK { try!(self.fg(color)); }
try!(write!(self, "{}\n", message.to_string()));
try!(self.reset());
try!(self.flush());
Ok(())
}
pub fn say_status<T, U>(&mut self, status: T, message: U, color: Color)
-> io::Result<()>
where T: fmt::Display, U: fmt::Display
{
try!(self.reset());
if color != BLACK { try!(self.fg(color)); }
if self.supports_attr(Attr::Bold) { try!(self.attr(Attr::Bold)); }
try!(write!(self, "{:>12}", status.to_string()));
try!(self.reset());
try!(write!(self, " {}\n", message));
try!(self.flush());
Ok(())
}
fn fg(&mut self, color: color::Color) -> term::Result<()> {
match self.terminal {
Colored(ref mut c) => c.fg(color),
NoColor(_) => Ok(())
}
}
fn attr(&mut self, attr: Attr) -> term::Result<()> {
match self.terminal {
Colored(ref mut c) => c.attr(attr),
NoColor(_) => Ok(())
}
}
fn supports_attr(&self, attr: Attr) -> bool {
match self.terminal {
Colored(ref c) => c.supports_attr(attr),
NoColor(_) => false
}
}
fn reset(&mut self) -> term::Result<()> {
match self.terminal {
Colored(ref mut c) => c.reset(),
NoColor(_) => Ok(())
}
}
}
impl Write for Shell {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
match self.terminal {
Colored(ref mut c) => c.write(buf),
NoColor(ref mut n) => n.write(buf)
}
}
fn flush(&mut self) -> io::Result<()> {
match self.terminal {
Colored(ref mut c) => c.flush(),
NoColor(ref mut n) => n.flush()
}
}
}
#[cfg(test)]
mod test {
use MultiShell;
#[test]
fn create_multishell() {
MultiShell::new_stdio(false);
}
#[test]
fn create_multishell_verbose() {
MultiShell::new_stdio(true);
}
}