imdl 0.1.16

📦 A 40' shipping container for the internet
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::common::*;

pub(crate) struct OutputStream {
  active: bool,
  stream: Box<dyn Write>,
  style: bool,
  term: bool,
}

impl OutputStream {
  pub(crate) fn stdout(style: bool) -> OutputStream {
    let term = atty::is(atty::Stream::Stdout);
    Self {
      stream: Box::new(io::stdout()),
      style: style && term,
      active: true,
      term,
    }
  }

  pub(crate) fn stderr(style: bool) -> OutputStream {
    Self {
      term: style && atty::is(atty::Stream::Stderr),
      stream: Box::new(io::stderr()),
      active: true,
      style,
    }
  }

  #[cfg(test)]
  pub(crate) fn new(stream: Box<dyn Write>, style: bool, term: bool, active: bool) -> OutputStream {
    Self {
      active,
      stream,
      style,
      term,
    }
  }

  pub(crate) fn set_use_color(&mut self, use_color: UseColor) {
    match use_color {
      UseColor::Always => self.style = true,
      UseColor::Auto => {}
      UseColor::Never => self.style = false,
    }
  }

  pub(crate) fn set_is_term(&mut self, term: bool) {
    self.term = term;
  }

  pub(crate) fn is_term(&self) -> bool {
    self.term
  }

  pub(crate) fn is_styled(&self) -> bool {
    self.style
  }

  pub(crate) fn is_styled_term(&self) -> bool {
    self.is_styled() && self.is_term()
  }

  pub(crate) fn style(&self) -> Style {
    Style::from_active(self.style)
  }

  pub(crate) fn set_active(&mut self, active: bool) {
    self.active = active;
  }
}

impl Write for OutputStream {
  fn write(&mut self, data: &[u8]) -> io::Result<usize> {
    if self.active {
      self.stream.write(data)
    } else {
      Ok(data.len())
    }
  }

  fn flush(&mut self) -> io::Result<()> {
    self.stream.flush()
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn active() {
    let capture = Capture::new();
    let mut stream = OutputStream::new(Box::new(capture.clone()), false, false, true);
    stream.write_all("hello".as_bytes()).unwrap();
    assert_eq!(capture.string(), "hello");
  }

  #[test]
  fn inactive() {
    let capture = Capture::new();
    let mut stream = OutputStream::new(Box::new(capture.clone()), false, false, false);
    stream.write_all("hello".as_bytes()).unwrap();
    assert_eq!(capture.string(), "");
  }
}