bluegum 0.1.1

A tree printer with rich formatting, alternate values, debug info, and flexible structure - perfect for ASTs and complex data visualization
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Copyright Two Neutron Stars Incorporated and contributors
// SPDX-License-Identifier: BlueOak-1.0.0

//! Built-in implementations of `Bluegum` and `BluegumWithState` for primitive
//! types and common standard library types.

use crate::{
  Bluegum,
  BluegumWithState,
  Builder,
};

/// Implementation for unit type
impl Bluegum for () {
  fn node(&self, b: &mut crate::Builder) {
    b.name("Unit");
  }
}

/// Implementation for Vec<T> where T implements Bluegum
impl<T> Bluegum for Vec<T>
where
  T: Bluegum,
{
  fn node(&self, b: &mut crate::Builder) {
    b.name("Vec").add_nodes("items", self);
  }
}

/// Implementation for 2-tuples where both types implement Bluegum
/// TODO: Extend to tuples up to 12 elements (gold-wqj)
impl<T1, T2> Bluegum for (T1, T2)
where
  T1: Bluegum,
  T2: Bluegum,
{
  fn node(&self, b: &mut crate::Builder) {
    b.name("(T1,T2)")
      .add_node("T1", &self.0)
      .add_node("T2", &self.1);
  }
}

/// Stateful implementation for unit type
impl<State> BluegumWithState<State> for () {
  fn node_with_state(&self, b: &mut crate::Builder, _state: &State) {
    b.name("Unit");
  }
}

/// Stateful implementation for Vec<T> where T implements BluegumWithState
impl<State, T> BluegumWithState<State> for Vec<T>
where
  T: BluegumWithState<State>,
{
  fn node_with_state(&self, b: &mut crate::Builder, state: &State) {
    b.add_builders(
      self
        .iter()
        .map(|node| Builder::render_with_state(node, state))
        .collect::<Vec<Builder>>(),
    );
  }
}

/// Stateful implementation for 2-tuples where both types implement
/// BluegumWithState TODO: Extend to tuples up to 12 elements (gold-d68)
impl<State, T1, T2> BluegumWithState<State> for (T1, T2)
where
  T1: BluegumWithState<State>,
  T2: BluegumWithState<State>,
{
  fn node_with_state(&self, b: &mut crate::Builder, state: &State) {
    b.name("(T1,T2)")
      .add_node("T1", &self.0)
      .add_node("T2", &self.1);
  }
}

/// A simple leaf node helper for creating nodes with just fields (no child
/// nodes)
pub struct Leaf<'a> {
  name:   String,
  fields: Vec<(&'a str, String)>,
}

impl<'a> Leaf<'a> {
  /// Create a new Leaf node with the given name and fields
  pub fn new(name: String, fields: &[(&'a str, String)]) -> Self {
    Self {
      name,
      fields: fields.into(),
    }
  }
}

impl Bluegum for Leaf<'_> {
  fn node(&self, b: &mut crate::Builder) {
    b.name(&self.name);

    for (name, value) in &self.fields {
      b.field(name, value);
    }
  }
}

/// Macro to implement Bluegum and BluegumWithState for primitive types
///
/// This macro generates implementations that display the type name and
/// show the debug representation as an alternate value.
macro_rules! impl_bluegum_for_primitive {
  ($($ty:ty),* $(,)?) => {
    $(
      impl $crate::Bluegum for $ty {
        fn node(&self, b: &mut $crate::Builder) {
          b.name(stringify!($ty)).alt(&format!("{:?}", self));
        }
      }

      impl<State> $crate::BluegumWithState<State> for $ty {
        fn node_with_state(&self, b: &mut $crate::Builder, _state: &State) {
          b.name(stringify!($ty)).alt(&format!("{:?}", self));
        }
      }
    )*
  };
}

// Implement Bluegum for common primitive types
impl_bluegum_for_primitive! {
  u8, u16, u32, u64, u128, usize,
  i8, i16, i32, i64, i128, isize,
  f32, f64,
  bool,
  char,
  String,
}