use std::collections::HashMap;
use std::env;
use std::error;
use std::fmt;
use std::fs::File;
use std::io::prelude::*;
use std::io;
use std::path::Path;
use Attr;
use color;
use Terminal;
use UnwrappableTerminal;
use self::searcher::get_dbpath_for_term;
use self::parser::compiled::{parse, msys_terminfo};
use self::parm::{expand, Variables, Param};
#[derive(Debug)]
pub struct TermInfo {
pub names: Vec<String> ,
pub bools: HashMap<String, bool>,
pub numbers: HashMap<String, u16>,
pub strings: HashMap<String, Vec<u8> >
}
#[derive(Debug)]
pub enum Error {
TermUnset,
MalformedTerminfo(String),
IoError(io::Error),
}
impl error::Error for Error {
fn description(&self) -> &str { "failed to create TermInfo" }
fn cause(&self) -> Option<&error::Error> {
use self::Error::*;
match self {
&IoError(ref e) => Some(e),
_ => None,
}
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use self::Error::*;
match self {
&TermUnset => Ok(()),
&MalformedTerminfo(ref e) => e.fmt(f),
&IoError(ref e) => e.fmt(f),
}
}
}
impl TermInfo {
pub fn from_env() -> Result<TermInfo, Error> {
let term = match env::var("TERM") {
Ok(name) => TermInfo::from_name(&name),
Err(..) => return Err(Error::TermUnset),
};
if term.is_err() && env::var("MSYSCON").ok().map_or(false, |s| "mintty.exe" == s) {
Ok(msys_terminfo())
} else {
term
}
}
pub fn from_name(name: &str) -> Result<TermInfo, Error> {
get_dbpath_for_term(name).ok_or_else(|| {
Error::IoError(io::Error::new(io::ErrorKind::NotFound,
"terminfo file not found"))
}).and_then(|p| {
TermInfo::from_path(&p)
})
}
pub fn from_path(path: &Path) -> Result<TermInfo, Error> {
File::open(path).map_err(|e| {
Error::IoError(e)
}).and_then(|ref mut file| {
parse(file, false).map_err(|e| {
Error::MalformedTerminfo(e)
})
})
}
}
pub mod searcher;
pub mod parser {
pub mod compiled;
}
pub mod parm;
fn cap_for_attr(attr: Attr) -> &'static str {
match attr {
Attr::Bold => "bold",
Attr::Dim => "dim",
Attr::Italic(true) => "sitm",
Attr::Italic(false) => "ritm",
Attr::Underline(true) => "smul",
Attr::Underline(false) => "rmul",
Attr::Blink => "blink",
Attr::Standout(true) => "smso",
Attr::Standout(false) => "rmso",
Attr::Reverse => "rev",
Attr::Secure => "invis",
Attr::ForegroundColor(_) => "setaf",
Attr::BackgroundColor(_) => "setab"
}
}
pub struct TerminfoTerminal<T> {
num_colors: u16,
out: T,
ti: TermInfo,
}
impl<T: Write+Send> Terminal<T> for TerminfoTerminal<T> {
fn fg(&mut self, color: color::Color) -> io::Result<bool> {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
return self.apply_cap("setaf", &[Param::Number(color as i16)]);
}
Ok(false)
}
fn bg(&mut self, color: color::Color) -> io::Result<bool> {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
return self.apply_cap("setab", &[Param::Number(color as i16)]);
}
Ok(false)
}
fn attr(&mut self, attr: Attr) -> io::Result<bool> {
match attr {
Attr::ForegroundColor(c) => self.fg(c),
Attr::BackgroundColor(c) => self.bg(c),
_ => self.apply_cap(cap_for_attr(attr), &[]),
}
}
fn supports_attr(&self, attr: Attr) -> bool {
match attr {
Attr::ForegroundColor(_) | Attr::BackgroundColor(_) => {
self.num_colors > 0
}
_ => {
let cap = cap_for_attr(attr);
self.ti.strings.get(cap).is_some()
}
}
}
fn reset(&mut self) -> io::Result<bool> {
let cmd = match [
"sg0", "sgr", "op"
].iter().filter_map(|cap| {
self.ti.strings.get(*cap)
}).next() {
Some(op) => match expand(&op, &[], &mut Variables::new()) {
Ok(cmd) => cmd,
Err(_) => return Ok(false),
},
None => return Ok(false),
};
self.out.write_all(&cmd).map(|_|true)
}
fn get_ref<'a>(&'a self) -> &'a T { &self.out }
fn get_mut<'a>(&'a mut self) -> &'a mut T { &mut self.out }
}
impl<T: Write+Send> UnwrappableTerminal<T> for TerminfoTerminal<T> {
fn unwrap(self) -> T { self.out }
}
impl<T: Write+Send> TerminfoTerminal<T> {
pub fn new_with_terminfo(out: T, terminfo: TermInfo) -> TerminfoTerminal<T> {
let nc = if terminfo.strings.contains_key("setaf")
&& terminfo.strings.contains_key("setab") {
terminfo.numbers.get("colors").map_or(0, |&n| n)
} else { 0 };
TerminfoTerminal {
out: out,
ti: terminfo,
num_colors: nc,
}
}
pub fn new(out: T) -> Option<TerminfoTerminal<T>> {
TermInfo::from_env().map(move |ti| TerminfoTerminal::new_with_terminfo(out, ti)).ok()
}
fn dim_if_necessary(&self, color: color::Color) -> color::Color {
if color >= self.num_colors && color >= 8 && color < 16 {
color-8
} else { color }
}
fn apply_cap(&mut self, cmd: &str, params: &[Param]) -> io::Result<bool> {
if let Some(cmd) = self.ti.strings.get(cmd) {
if let Ok(s) = expand(&cmd, params, &mut Variables::new()) {
try!(self.out.write_all(&s));
return Ok(true)
}
}
Ok(false)
}
}
impl<T: Write> Write for TerminfoTerminal<T> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.out.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.out.flush()
}
}