kosame_dsl 0.3.0

Macro-based Rust ORM focused on developer ergonomics
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

use quote::ToTokens;
use syn::spanned::Spanned;

use super::{PrettyPrint, Printer, TextMode};

impl PrettyPrint for syn::Attribute {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        if self.meta.path().is_ident("doc") {
            // Docs comments are treated as regular comments by the pretty printer.
            return;
        }

        self.pound_token.pretty_print(printer);
        if let syn::AttrStyle::Inner(not) = &self.style {
            not.pretty_print(printer);
        }
        if let Some(source_text) = self.bracket_token.span.span().source_text() {
            source_text.pretty_print(printer);
        }
        printer.scan_same_line_trivia();
        printer.scan_break();
        " ".pretty_print(printer);
    }
}

impl PrettyPrint for syn::token::PathSep {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        printer.move_cursor(self.span().start());
        printer.scan_text("::".into(), TextMode::Always);
        printer.move_cursor(self.span().end());
    }
}

impl PrettyPrint for syn::Path {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        if let Some(leading_colon) = &self.leading_colon {
            leading_colon.pretty_print(printer);
        }

        for pair in self.segments.pairs() {
            let segment = pair.value();
            segment.ident.pretty_print(printer);

            match &segment.arguments {
                syn::PathArguments::None => {}
                syn::PathArguments::AngleBracketed(args) => {
                    args.pretty_print(printer);
                }
                syn::PathArguments::Parenthesized(args) => {
                    args.pretty_print(printer);
                }
            }

            if let Some(punct) = pair.punct() {
                punct.pretty_print(printer);
            }
        }
    }
}

impl PrettyPrint for syn::AngleBracketedGenericArguments {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        self.lt_token.pretty_print(printer);

        for pair in self.args.pairs() {
            pair.value().pretty_print(printer);

            if let Some(punct) = pair.punct() {
                printer.scan_no_break_trivia();
                punct.pretty_print(printer);
                printer.scan_trivia(true, true);
                " ".pretty_print(printer);
            }
        }

        self.gt_token.pretty_print(printer);
    }
}

impl PrettyPrint for syn::GenericArgument {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        // Use to_token_stream for generic arguments
        printer.move_cursor(self.span().start());
        printer.scan_text(self.to_token_stream().to_string().into(), TextMode::Always);
        printer.move_cursor(self.span().end());
    }
}

impl PrettyPrint for syn::ParenthesizedGenericArguments {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        use super::Delim;

        self.paren_token.pretty_print(printer, None, |printer| {
            for pair in self.inputs.pairs() {
                pair.value().pretty_print(printer);

                if let Some(punct) = pair.punct() {
                    printer.scan_no_break_trivia();
                    punct.pretty_print(printer);
                    printer.scan_trivia(true, true);
                    " ".pretty_print(printer);
                }
            }
        });

        // Handle return type if present
        match &self.output {
            syn::ReturnType::Default => {}
            syn::ReturnType::Type(arrow, ty) => {
                " ".pretty_print(printer);
                arrow.pretty_print(printer);
                " ".pretty_print(printer);
                ty.pretty_print(printer);
            }
        }
    }
}

impl PrettyPrint for syn::Type {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        // Use to_token_stream for types
        printer.move_cursor(self.span().start());
        printer.scan_text(self.to_token_stream().to_string().into(), TextMode::Always);
        printer.move_cursor(self.span().end());
    }
}

impl PrettyPrint for syn::token::RArrow {
    fn pretty_print(&self, printer: &mut Printer<'_>) {
        printer.move_cursor(self.span().start());
        printer.scan_text("->".into(), TextMode::Always);
        printer.move_cursor(self.span().end());
    }
}