25 releases

0.4.3 Aug 21, 2023
0.4.1 May 26, 2023
0.3.5 Feb 12, 2023
0.3.4 Oct 16, 2022
0.3.3 Jun 25, 2022

#54 in Procedural macros

Download history 37/week @ 2023-10-19 50/week @ 2023-10-26 25/week @ 2023-11-02 38/week @ 2023-11-09 23/week @ 2023-11-16 48/week @ 2023-11-23 90/week @ 2023-11-30 26/week @ 2023-12-07 46/week @ 2023-12-14 67/week @ 2023-12-21 44/week @ 2023-12-28 22/week @ 2024-01-04 29/week @ 2024-01-11 51/week @ 2024-01-18 93/week @ 2024-01-25 80/week @ 2024-02-01

253 downloads per month

MIT license

205KB
4K SLoC

dbg-pls

crate docs

A Debug-like trait for rust that outputs properly formatted code

Showcase

Take the following code:

let code = r#"
    [
        "Hello, World! I am a long string",
        420,
        "Wait, you can't mix and match types in arrays, is this python?",
        69,
        "Nice."
    ]
"#;
let expr: syn::Expr = syn::parse_str(code).unwrap();
println!("{expr:?}");

This outputs

Array(ExprArray { attrs: [], bracket_token: Bracket, elems: [Lit(ExprLit { attrs: [], lit: Str(LitStr { token: "Hello, World! I am a long string" }) }), Comma, Lit(ExprLit { attrs: [], lit: Int(LitInt { token: 420 }) }), Comma, Lit(ExprLit { attrs: [], lit: Str(LitStr { token: "Wait, you can't mix and match types in arrays, is this python?" }) }), Comma, Lit(ExprLit { attrs: [], lit: Int(LitInt { token: 69 }) }), Comma, Lit(ExprLit { attrs: [], lit: Str(LitStr { token: "Nice." }) })] })

which is far too dense to read.

If we change the println to use the alternate printing (:#?), then we get

Array(
    ExprArray {
        attrs: [],
        bracket_token: Bracket,
        elems: [
            Lit(
                ExprLit {
                    attrs: [],
                    lit: Str(
                        LitStr {
                            token: "Hello, World! I am a long string",
                        },
                    ),
                },
            ),
            Comma,
            Lit(
                ExprLit {
                    attrs: [],
                    lit: Int(
                        LitInt {
                            token: 420,
                        },
                    ),
                },
            ),
            Comma,
            Lit(
                ExprLit {
                    attrs: [],
                    lit: Str(
                        LitStr {
                            token: "Wait, you can't mix and match types in arrays, is this python?",
                        },
                    ),
                },
            ),
            Comma,
            Lit(
                ExprLit {
                    attrs: [],
                    lit: Int(
                        LitInt {
                            token: 69,
                        },
                    ),
                },
            ),
            Comma,
            Lit(
                ExprLit {
                    attrs: [],
                    lit: Str(
                        LitStr {
                            token: "Nice.",
                        },
                    ),
                },
            ),
        ],
    },
)

which is far too spread out to be natural.

This is where dbg_pls comes in. Replace the println with

println!("{}", dbg_pls::color(&expr));

And you get

Usage in libraries

cargo add dbg-pls

Add to your types

#[derive(dbg_pls::DebugPls)]

Usage for applications

cargo add dbg-pls +pretty

And print using pretty, eg

println!("{}", dbg_pls::pretty(&value));

Features

  • derive - enables the #[derive(DebugPls)] derive
  • pretty - enables the pretty function for pretty printing
  • colors - enables the color function for syntax highlighted printing

Example

use dbg_pls::{pretty, DebugPls};

#[derive(DebugPls, Copy, Clone)]
pub struct Demo {
    foo: i32,
    bar: &'static str,
}

let mut val = [Demo { foo: 5, bar: "hello" }; 10];
val[6].bar = "Hello, world! I am a very long string";

println!("{}", pretty(&val));

Outputs

[
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
    Demo {
        foo: 5,
        bar: "Hello, world! I am a very long string",
    },
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
    Demo { foo: 5, bar: "hello" },
]

Example (highlighting)

use dbg_pls::{color, DebugPls};

#[derive(DebugPls, Copy, Clone)]
pub struct Demo {
    foo: i32,
    bar: &'static str,
}

let mut val = [Demo { foo: 5, bar: "hello" }; 10];
val[6].bar = "Hello, world! I am a very long string";

println!("{}", color(&val));

Outputs:

Example (dbg-style macros)

use dbg_pls::{color, DebugPls};

#[derive(DebugPls, Copy, Clone)]
pub struct Demo {
    foo: i32,
    bar: &'static str,
}

let foo = 5;
let bar = "Hello, World! This is the color macro";
let _ = color!(Demo { foo, bar });

Outputs:

use dbg_pls::{pretty, DebugPls};

#[derive(DebugPls, Copy, Clone)]
pub struct Demo {
    foo: i32,
    bar: &'static str,
}

let foo = 5;
let bar = "hello";
let _ = pretty!(Demo { foo, bar });

Outputs:

[src/lib.rs:558] Demo { foo, bar } => Demo { foo: 5, bar: "hello" }

Dependencies

~0.4–1.6MB
~27K SLoC