Remove unused stuff and switch to pub(crate) whenever possible.

Author: crlf0710

library/test/src/term.rs

@@ -6,123 +6,62 @@
 //! a [terminfo][ti] database, and `WinConsole`, which uses the [Win32 Console
 //! API][win].
 //!
-//! ```
-//!
 //! [ansi]: https://en.wikipedia.org/wiki/ANSI_escape_code
 //! [win]: https://docs.microsoft.com/en-us/windows/console/character-mode-applications
 //! [ti]: https://en.wikipedia.org/wiki/Terminfo
 
 #![deny(missing_docs)]
 
-use std::io::prelude::*;
-use std::io::{self, Stderr, Stdout};
+use std::io::{self, prelude::*};
 
-pub use terminfo::TerminfoTerminal;
+pub(crate) use terminfo::TerminfoTerminal;
 #[cfg(windows)]
-pub use win::WinConsole;
+pub(crate) use win::WinConsole;
 
-pub mod terminfo;
+pub(crate) mod terminfo;
 
 #[cfg(windows)]
 mod win;
 
 /// Alias for stdout terminals.
-pub type StdoutTerminal = dyn Terminal<Output = Stdout> + Send;
-/// Alias for stderr terminals.
-pub type StderrTerminal = dyn Terminal<Output = Stderr> + Send;
+pub(crate) type StdoutTerminal = dyn Terminal + Send;
 
 #[cfg(not(windows))]
 /// Returns a Terminal wrapping stdout, or None if a terminal couldn't be
 /// opened.
-pub fn stdout() -> Option<Box<StdoutTerminal>> {
+pub(crate) fn stdout() -> Option<Box<StdoutTerminal>> {
     TerminfoTerminal::new(io::stdout()).map(|t| Box::new(t) as Box<StdoutTerminal>)
 }
 
 #[cfg(windows)]
 /// Returns a Terminal wrapping stdout, or None if a terminal couldn't be
 /// opened.
-pub fn stdout() -> Option<Box<StdoutTerminal>> {
+pub(crate) fn stdout() -> Option<Box<StdoutTerminal>> {
     TerminfoTerminal::new(io::stdout())
         .map(|t| Box::new(t) as Box<StdoutTerminal>)
         .or_else(|| WinConsole::new(io::stdout()).ok().map(|t| Box::new(t) as Box<StdoutTerminal>))
 }
 
-#[cfg(not(windows))]
-/// Returns a Terminal wrapping stderr, or None if a terminal couldn't be
-/// opened.
-pub fn stderr() -> Option<Box<StderrTerminal>> {
-    TerminfoTerminal::new(io::stderr()).map(|t| Box::new(t) as Box<StderrTerminal>)
-}
-
-#[cfg(windows)]
-/// Returns a Terminal wrapping stderr, or None if a terminal couldn't be
-/// opened.
-pub fn stderr() -> Option<Box<StderrTerminal>> {
-    TerminfoTerminal::new(io::stderr())
-        .map(|t| Box::new(t) as Box<StderrTerminal>)
-        .or_else(|| WinConsole::new(io::stderr()).ok().map(|t| Box::new(t) as Box<StderrTerminal>))
-}
-
 /// Terminal color definitions
 #[allow(missing_docs)]
-pub mod color {
+#[cfg_attr(not(windows), allow(dead_code))]
+pub(crate) mod color {
     /// Number for a terminal color
-    pub type Color = u32;
-
-    pub const BLACK: Color = 0;
-    pub const RED: Color = 1;
-    pub const GREEN: Color = 2;
-    pub const YELLOW: Color = 3;
-    pub const BLUE: Color = 4;
-    pub const MAGENTA: Color = 5;
-    pub const CYAN: Color = 6;
-    pub const WHITE: Color = 7;
-
-    pub const BRIGHT_BLACK: Color = 8;
-    pub const BRIGHT_RED: Color = 9;
-    pub const BRIGHT_GREEN: Color = 10;
-    pub const BRIGHT_YELLOW: Color = 11;
-    pub const BRIGHT_BLUE: Color = 12;
-    pub const BRIGHT_MAGENTA: Color = 13;
-    pub const BRIGHT_CYAN: Color = 14;
-    pub const BRIGHT_WHITE: Color = 15;
-}
-
-/// Terminal attributes for use with term.attr().
-///
-/// Most attributes can only be turned on and must be turned off with term.reset().
-/// The ones that can be turned off explicitly take a boolean value.
-/// Color is also represented as an attribute for convenience.
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum Attr {
-    /// Bold (or possibly bright) mode
-    Bold,
-    /// Dim mode, also called faint or half-bright. Often not supported
-    Dim,
-    /// Italics mode. Often not supported
-    Italic(bool),
-    /// Underline mode
-    Underline(bool),
-    /// Blink mode
-    Blink,
-    /// Standout mode. Often implemented as Reverse, sometimes coupled with Bold
-    Standout(bool),
-    /// Reverse mode, inverts the foreground and background colors
-    Reverse,
-    /// Secure mode, also called invis mode. Hides the printed text
-    Secure,
-    /// Convenience attribute to set the foreground color
-    ForegroundColor(color::Color),
-    /// Convenience attribute to set the background color
-    BackgroundColor(color::Color),
+    pub(crate) type Color = u32;
+
+    pub(crate) const BLACK: Color = 0;
+    pub(crate) const RED: Color = 1;
+    pub(crate) const GREEN: Color = 2;
+    pub(crate) const YELLOW: Color = 3;
+    pub(crate) const BLUE: Color = 4;
+    pub(crate) const MAGENTA: Color = 5;
+    pub(crate) const CYAN: Color = 6;
+    pub(crate) const WHITE: Color = 7;
 }
 
 /// A terminal with similar capabilities to an ANSI Terminal
 /// (foreground/background colors etc).
 pub trait Terminal: Write {
-    /// The terminal's output writer type.
-    type Output: Write;
-
     /// Sets the foreground color to the given color.
     ///
     /// If the color is a bright color, but the terminal only supports 8 colors,
@@ -132,23 +71,6 @@ pub trait Terminal: Write {
     /// if there was an I/O error.
     fn fg(&mut self, color: color::Color) -> io::Result<bool>;
 
-    /// Sets the background color to the given color.
-    ///
-    /// If the color is a bright color, but the terminal only supports 8 colors,
-    /// the corresponding normal color will be used instead.
-    ///
-    /// Returns `Ok(true)` if the color was set, `Ok(false)` otherwise, and `Err(e)`
-    /// if there was an I/O error.
-    fn bg(&mut self, color: color::Color) -> io::Result<bool>;
-
-    /// Sets the given terminal attribute, if supported. Returns `Ok(true)`
-    /// if the attribute was supported, `Ok(false)` otherwise, and `Err(e)` if
-    /// there was an I/O error.
-    fn attr(&mut self, attr: Attr) -> io::Result<bool>;
-
-    /// Returns `true` if the given terminal attribute is supported.
-    fn supports_attr(&self, attr: Attr) -> bool;
-
     /// Resets all terminal attributes and colors to their defaults.
     ///
     /// Returns `Ok(true)` if the terminal was reset, `Ok(false)` otherwise, and `Err(e)` if there
@@ -160,15 +82,4 @@ pub trait Terminal: Write {
     /// else that might flush stdout's buffer (e.g., writing a line of text), you should flush after
     /// calling reset.
     fn reset(&mut self) -> io::Result<bool>;
-
-    /// Gets an immutable reference to the stream inside
-    fn get_ref(&self) -> &Self::Output;
-
-    /// Gets a mutable reference to the stream inside
-    fn get_mut(&mut self) -> &mut Self::Output;
-
-    /// Returns the contained stream, destroying the `Terminal`
-    fn into_inner(self) -> Self::Output
-    where
-        Self: Sized;
 }

library/test/src/term/terminfo/mod.rs

@@ -9,7 +9,6 @@ use std::io::{self, prelude::*, BufReader};
 use std::path::Path;
 
 use super::color;
-use super::Attr;
 use super::Terminal;
 
 use parm::{expand, Param, Variables};
@@ -18,20 +17,20 @@ use searcher::get_dbpath_for_term;
 
 /// A parsed terminfo database entry.
 #[derive(Debug)]
-pub struct TermInfo {
+pub(crate) struct TermInfo {
     /// Names for the terminal
-    pub names: Vec<String>,
+    pub(crate) names: Vec<String>,
     /// Map of capability name to boolean value
-    pub bools: HashMap<String, bool>,
+    pub(crate) bools: HashMap<String, bool>,
     /// Map of capability name to numeric value
-    pub numbers: HashMap<String, u32>,
+    pub(crate) numbers: HashMap<String, u32>,
     /// Map of capability name to raw (unexpanded) string
-    pub strings: HashMap<String, Vec<u8>>,
+    pub(crate) strings: HashMap<String, Vec<u8>>,
 }
 
 /// A terminfo creation error.
 #[derive(Debug)]
-pub enum Error {
+pub(crate) enum Error {
     /// TermUnset Indicates that the environment doesn't include enough information to find
     /// the terminfo entry.
     TermUnset,
@@ -64,7 +63,7 @@ impl fmt::Display for Error {
 
 impl TermInfo {
     /// Creates a TermInfo based on current environment.
-    pub fn from_env() -> Result<TermInfo, Error> {
+    pub(crate) fn from_env() -> Result<TermInfo, Error> {
         let term = match env::var("TERM") {
             Ok(name) => TermInfo::from_name(&name),
             Err(..) => return Err(Error::TermUnset),
@@ -79,7 +78,7 @@ impl TermInfo {
     }
 
     /// Creates a TermInfo for the named terminal.
-    pub fn from_name(name: &str) -> Result<TermInfo, Error> {
+    pub(crate) 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"))
@@ -88,7 +87,7 @@ impl TermInfo {
     }
 
     /// Parse the given TermInfo.
-    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<TermInfo, Error> {
+    pub(crate) fn from_path<P: AsRef<Path>>(path: P) -> Result<TermInfo, Error> {
         Self::_from_path(path.as_ref())
     }
     // Keep the metadata small
@@ -99,43 +98,24 @@ impl TermInfo {
     }
 }
 
-pub mod searcher;
+pub(crate) mod searcher;
 
 /// TermInfo format parsing.
-pub mod parser {
+pub(crate) mod parser {
     //! ncurses-compatible compiled terminfo format parsing (term(5))
-    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(crate) mod compiled;
 }
+pub(crate) mod parm;
 
 /// A Terminal that knows how many colors it supports, with a reference to its
 /// parsed Terminfo database record.
-pub struct TerminfoTerminal<T> {
+pub(crate) struct TerminfoTerminal<T> {
     num_colors: u32,
     out: T,
     ti: TermInfo,
 }
 
 impl<T: Write + Send> Terminal for TerminfoTerminal<T> {
-    type Output = T;
     fn fg(&mut self, color: color::Color) -> io::Result<bool> {
         let color = self.dim_if_necessary(color);
         if self.num_colors > color {
@@ -144,32 +124,6 @@ impl<T: Write + Send> Terminal for TerminfoTerminal<T> {
         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 i32)]);
-        }
-        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> {
         // are there any terminals that have color/attrs and not sgr0?
         // Try falling back to sgr, then op
@@ -182,26 +136,11 @@ impl<T: Write + Send> Terminal for TerminfoTerminal<T> {
         };
         self.out.write_all(&cmd).and(Ok(true))
     }
-
-    fn get_ref(&self) -> &T {
-        &self.out
-    }
-
-    fn get_mut(&mut self) -> &mut T {
-        &mut self.out
-    }
-
-    fn into_inner(self) -> T
-    where
-        Self: Sized,
-    {
-        self.out
-    }
 }
 
 impl<T: Write + Send> TerminfoTerminal<T> {
     /// Creates a new TerminfoTerminal with the given TermInfo and Write.
-    pub fn new_with_terminfo(out: T, terminfo: TermInfo) -> TerminfoTerminal<T> {
+    pub(crate) 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)
@@ -215,7 +154,7 @@ impl<T: Write + Send> TerminfoTerminal<T> {
     /// Creates a new TerminfoTerminal for the current environment with the given Write.
     ///
     /// Returns `None` when the terminfo cannot be found or parsed.
-    pub fn new(out: T) -> Option<TerminfoTerminal<T>> {
+    pub(crate) fn new(out: T) -> Option<TerminfoTerminal<T>> {
         TermInfo::from_env().map(move |ti| TerminfoTerminal::new_with_terminfo(out, ti)).ok()
     }