aliased 0.1.0

Rewrite Debug output to replace long opaque values with short human-friendly aliases.
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

//! Aliasing API parameterized by an explicit [`AliasContext`].
//!
//! Use this flavor when you want isolated contexts — for example, one per
//! test, so registrations from one test cannot leak into another.

use std::any::TypeId;
use std::fmt;

use crate::shared::{self, AliasContext};

#[cfg(feature = "global")]
pub use crate::global::global_ctx;

/// Extension trait providing aliasing methods that operate on an explicit
/// [`AliasContext`]. Implemented for every `T: Debug + 'static`.
pub trait Aliasing: fmt::Debug + 'static {
    /// Wrap `self` so that formatting it applies the aliases registered in
    /// `ctx`.
    fn aliased<'v, 'c>(&'v self, ctx: &'c AliasContext) -> Aliased<'v, 'c, Self> {
        Aliased { val: self, ctx }
    }

    /// Set a short prefix shown alongside every alias of this type
    /// (e.g. `⟪K|alice⟫`). Should be called at most once per type.
    fn alias_prefix(ctx: &AliasContext, prefix: &str) {
        shared::set_prefix(ctx, TypeId::of::<Self>(), prefix);
    }

    /// Assign `self` an auto-incrementing numeric alias scoped to its type.
    /// Returns `self` for chaining.
    fn alias_numbered(&self, ctx: &AliasContext) -> &Self {
        shared::register_numbered(
            ctx,
            TypeId::of::<Self>(),
            format!("{self:?}"),
            format!("{self:#?}"),
        );
        self
    }

    /// Assign `self` an explicit named alias. Returns `self` for chaining.
    fn alias_named(&self, ctx: &AliasContext, name: &str) -> &Self {
        shared::register_named(
            ctx,
            TypeId::of::<Self>(),
            format!("{self:?}"),
            format!("{self:#?}"),
            name,
        );
        self
    }
}

impl<T> Aliasing for T where T: fmt::Debug + 'static {}

/// `Debug` wrapper produced by [`Aliasing::aliased`]. Formatting it runs the
/// inner value's `Debug` (or `{:#?}`) output and substitutes registered
/// aliases drawn from the context it was created with.
pub struct Aliased<'v, 'c, T: ?Sized> {
    val: &'v T,
    ctx: &'c AliasContext,
}

impl<T: ?Sized + fmt::Debug> fmt::Debug for Aliased<'_, '_, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        shared::fmt_aliased(self.val, self.ctx, f)
    }
}