schnauzer 0.3.5

Library for parsing Mach-O files
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
114
115
116

pub mod table;
pub mod hex;

use colored::{self, ColoredString, Colorize};
use std::fmt::Display;

use crate::auto_enum_fields::Field;

pub struct Printer {}

impl Clone for Printer {
    fn clone(&self) -> Self {
        Self {  }
    }
}

impl Printer {
    pub(crate) fn out_dashed_field(&self, name: &str, value: &str, level: usize) {
        self.out_field_dash(level);
        self.out_default_colored_field(name, value, "\n");
    }
    
    pub(crate) fn out_field_dash(&self, level: usize) {
        let tail = format! {"{}{}", "|", "*".dimmed()};
        print!("{}{}", " ".repeat(level + 1), tail);
    }
    
    pub(crate) fn out_list_item_dash(&self, level: usize, index: usize) {
        print!(
            "{}[{}] ",
            " ".repeat(level),
            index.to_string().red()
        );
    }

    pub(crate) fn out_index_path_dash(&self, level: usize, index_path: Vec<usize>) {
        let strings: Vec<String> = index_path.iter().map(|f| f.to_string().red().to_string()).collect();
        let path = strings.join(&":".white().to_string());

        print!(
            "{}[{}] ",
            " ".repeat(level),
            path,
        );
    }
    
    pub(crate) fn out_default_colored_fields(&self, fields: Vec<Field>, tail: &str) {
        let pairs: Vec<String> = fields.iter().map(|f| {
            ColoredField::new_default(&f.name, &f.value).to_string()
        }).collect();

        print!("{}{tail}", pairs.join(", "));
    }

    pub(crate) fn out_default_colored_field(&self, name: &str, value: &str, delimiter: &str) {
        self.out_field(name.white(), value.green(), delimiter);
    }
    
    pub(crate) fn out_field(&self, name: ColoredString, value: ColoredString, delimiter: &str) {
        if name.len() > 0 {
            let field = ColoredField::new(name, value);
            print!("{field}");
        }
        print!("{delimiter}");
    }
    
    pub(crate) fn out_tile(&self, level: usize) {
        self.out_string("-".repeat(20), level)
    }
    
    pub(crate) fn out_string(&self, string: String, level: usize) {
        print!("{}", " ".repeat(level));
        println!("{string}");
    }

    pub(crate) fn print_line(&self, line: impl Display) {
        println!("{line}");
    }

    pub(crate) fn print_string(&self, string: impl Display) {
        print!("{string}");
    }
    
    pub(crate) fn print_strings(&self, strings: Vec<impl Display>, sep: &str) {
        let v: Vec<String> = strings.iter().map(|s| format!("{s}")).collect();
        print!("{}", v.join(sep));
    }

    pub(crate) fn print_colored_string(&self, string: ColoredString) {
        print!("{string}");
    }
}

struct ColoredField {
    string: String
}

impl ColoredField {
    fn new(name: ColoredString, value: ColoredString) -> Self {
        Self {
            string: format!("{}: {}", name, value),
        }
    }

    fn new_default(name: &str, value: &str) -> Self {
        Self {
            string: format!("{}: {}", name.white(), value.green()),
        }
    }
}

impl std::fmt::Display for ColoredField {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", &self.string)
    }
}