crud-pretty-struct 0.1.7

Pretty display for struct
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
107
108
109
110
111
112
113

use miette::Result;
use owo_colors::OwoColorize;

pub fn identity_formatter(x: &dyn ToString, _: bool) -> Result<(String, bool)> {
  Ok((x.to_string(), false))
}

pub fn bool_check_formatter(b: &dyn ToString, colored: bool) -> Result<(String, bool)> {
  Ok((
    match (b.to_string().as_str(), colored) {
      ("true", true) => "✔".green().to_string(),
      ("true", false) => "✔".to_string(),
      (_, true) => "✘".red().to_string(),
      (_, false) => "✘".to_string(),
    },
    colored,
  ))
}

// pub fn suffix_formatter(suffix: String) -> Box<Formatter> {
//   Box::new(move |x: &dyn ToString, _: bool| -> Result<(String, bool)> {
//     Ok((format!("{}{suffix}", x.to_string()), false))
//   })
// }

#[cfg(feature = "chrono")]
pub fn timestamp_formatter(value: &dyn ToString, _: bool) -> Result<(String, bool)> {
  use chrono::{FixedOffset, NaiveDateTime};
  use miette::{miette, Context, IntoDiagnostic};
  let d = NaiveDateTime::parse_from_str(value.to_string().as_str(), "%s")
    .into_diagnostic()
    .with_context(|| format!("Can't parse timestamps: {}", value.to_string()))?
    .and_local_timezone(FixedOffset::east_opt(0).ok_or(miette!("Can't create timezone"))?)
    .unwrap();
  Ok((d.to_string(), false))
}

#[cfg(feature = "humantime")]
pub fn duration_formatter(value: &dyn ToString, _: bool) -> Result<(String, bool)> {
  use humantime::format_duration;
  use miette::{Context, IntoDiagnostic};
  use std::time::Duration;

  let d = Duration::from_secs_f64(
    value
      .to_string()
      .parse::<f64>()
      .into_diagnostic()
      .with_context(|| format!("Can't parse duration: {}", value.to_string()))?
      .abs(),
  );
  Ok((format_duration(d).to_string(), false))
}

#[cfg(feature = "markdown")]
pub fn markdown_formatter(value: &dyn ToString, _: bool) -> Result<(String, bool)> {
  Ok((termimad::term_text(&value.to_string()).to_string(), true))
}

#[cfg(feature = "bytesize")]
pub fn byte_formatter(value: &dyn ToString, _: bool) -> Result<(String, bool)> {
  use bytesize::ByteSize;
  use miette::{Context, IntoDiagnostic};

  let d = ByteSize(
    value
      .to_string()
      .parse::<u64>()
      .into_diagnostic()
      .with_context(|| format!("Can't parse bytes: {}", value.to_string()))?,
  );
  Ok((d.to_string(), false))
}

#[cfg(test)]
mod tests {
  #[test]
  #[cfg(feature = "humantime")]
  fn duration_formatter_u64() {
    use crate::formatters::duration_formatter;
    assert_eq!(
      duration_formatter(&"14", false).unwrap(),
      ("14s".to_string(), false)
    );
  }

  #[test]
  #[cfg(feature = "humantime")]
  fn duration_formatter_f64() {
    use crate::formatters::duration_formatter;
    assert_eq!(
      duration_formatter(&"784.15", false).unwrap(),
      ("13m 4s 150ms".to_string(), false)
    );
  }

  #[test]
  #[cfg(feature = "humantime")]
  fn duration_formatter_f64_negative() {
    use crate::formatters::duration_formatter;
    assert_eq!(
      duration_formatter(&"-784.15", false).unwrap(),
      ("13m 4s 150ms".to_string(), false)
    );
  }

  // #[test]
  // #[cfg(feature = "humantime")]
  // fn duration_formatter_err() {
  //   use crate::formatters::duration_formatter;
  //   assert_eq!(duration_formatter(&"x7", false), miette::Result::Err(()));
  // }
}