b0x 1.0.1

A simple CLI tool to display information about the provided input (integers, IP addresses, strings).
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
117
118
119
120
121
122

//! Defines passes

use crate::config::Config;
use colored::*;

const INFO_INDENT: &str = "   ";

/// Information, value (what is displayed on the right).
pub enum Info {
    /// Available information.
    Available(String),
    /// Shows `n/a`.
    NotAvailable,
    /// Shows `other`.
    Other,
}

/// One pass that gives related information regarding `T`.
pub struct Pass<'a, T>(&'a str, &'a dyn Fn(&T) -> Vec<(&'a str, Info)>);

impl<'a, T> Pass<'a, T> {
    fn name(&self) -> &'a str {
        &self.0
    }

    fn run(&self, input: &T) -> Vec<(&'a str, Info)> {
        (self.1)(input)
    }
}

/// A sequence of passes. This is what runs for a given value.
pub trait PassSequence<'a> {
    /// Type of the value that this sequence can give information about.
    type T: 'a;
    /// Name of `T` which will be displayed in the beginning of output via `found TY_NAME(value)`.
    const TY_NAME: &'static str;
    /// Passes which this sequence consists of.
    const PASSES: &'a [Pass<'a, Self::T>];

    /// Runs all passes in the sequence that are not ignored and returns the combined result.
    fn run(input: &Self::T, config: &Config) -> Vec<(&'a str, Result<Vec<(&'a str, Info)>, ()>)> {
        let mut results = Vec::new();
        for pass in Self::PASSES {
            results.push((
                pass.name(),
                if !config.is_ignored(&pass.name()) {
                    Ok(pass.run(input))
                } else {
                    Err(())
                },
            ));
        }

        results
    }
}

/// Runs a pass sequence for a given input, outputting all received information.
pub fn run<'a, S>(input: &S::T, config: &Config)
where
    S: PassSequence<'a>,
    S::T: ToString + 'a,
{
    let data = input.to_string().red().bold();
    let ty = S::TY_NAME.yellow().bold();

    println!("found {}({})", ty, data);

    for (name, result) in S::run(input, config) {
        println!(
            "{} {} {}",
            match result {
                Ok(_) => "➔",
                Err(_) => "✘",
            },
            name.magenta().bold(),
            match result {
                Ok(_) => "",
                Err(_) => "ignored",
            },
        );

        if let Ok(result) = result {
            for (name, info) in result {
                println!(
                    "{}{} {}",
                    INFO_INDENT,
                    name.to_string().blue().bold(),
                    match info {
                        Info::Available(value) => value.to_string().green().bold(),
                        Info::NotAvailable => "n/a".cyan().bold(),
                        Info::Other => "other".cyan().bold(),
                    }
                );
            }
        }
    }
}

macro_rules! push {
    ($result:ident, $name:expr, n / a) => {
        $result.push(($name, $crate::passes::Info::NotAvailable))
    };

    ($result:ident, $name:expr, other) => {
        $result.push(($name, $crate::passes::Info::Other))
    };

    ($result:ident, $name:expr, $value:expr) => {
        $result.push(($name, $crate::passes::Info::Available($value.to_string())))
    };
}

macro_rules! pass_sequence {
    ($($id:expr),*) => {
        &[$($crate::passes::Pass(stringify!($id), &$id)),*]
    }
}

pub mod integer;
pub mod ip_addr;
pub mod string;