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

mod ctxt;
mod formatting;
mod output;
mod print_array;
mod print_comment;
mod print_enum;
mod print_fields;
mod print_map;
mod print_optional;
mod print_scalar;
mod print_struct;
mod print_tuple;
mod value_to_string;

use self::{ctxt::*, output::*};
use crate::printers::prelude::*;
use std::borrow::Cow;

pub use self::formatting::*;

#[derive(Debug, Default)]
pub struct Printer<'a> {
    visibility: Visibility,
    formatting: Option<&'a Formatting>,
    value: Option<&'a Value>,
}

impl<'a> Printer<'a> {
    /// Specifies how `skip_serializing` / `skip_deserializing` should be
    /// understood:
    ///
    /// ```
    /// use doku::Document;
    /// use doku::json::*;
    /// use doku::Visibility;
    /// use serde::Serialize;
    ///
    /// #[derive(Serialize, Document)]
    /// struct Person {
    ///     name: String,
    ///     #[serde(skip_serializing)]
    ///     password: String,
    ///     surname: String,
    /// }
    ///
    /// let doc = Printer::default()
    ///     .with_visibility(Visibility::SerializableOnly)
    ///     .print(&Person::ty());
    ///
    /// doku::assert_doc!(r#"
    ///   {
    ///     "name": "string",
    ///     "surname": "string"
    ///   }
    /// "#, doc);
    /// ```
    pub fn set_visibility(&mut self, value: Visibility) {
        self.visibility = value;
    }

    /// A consuming variant of [`Self::set_visibility()`].
    pub fn with_visibility(mut self, value: Visibility) -> Self {
        self.set_visibility(value);
        self
    }

    pub fn set_formatting(&mut self, value: &'a Formatting) {
        self.formatting = Some(value);
    }

    /// A consuming variant of [`Self::set_formatting()`].
    pub fn with_formatting(mut self, value: &'a Formatting) -> Self {
        self.set_formatting(value);
        self
    }

    pub fn set_value(&mut self, value: &'a Value) {
        self.value = Some(value);
    }

    /// A consuming variant of [`Self::set_value()`].
    pub fn with_value(mut self, value: &'a Value) -> Self {
        self.set_value(value);
        self
    }

    pub fn print(&self, ty: &'a Type) -> String {
        let fmt = self
            .formatting
            .map(Cow::Borrowed)
            .unwrap_or_else(|| Cow::Owned(Default::default()));

        let mut out = Output::new(fmt.as_ref());

        Ctxt {
            ty,
            val: self.value,
            vis: self.visibility,
            fmt: fmt.as_ref(),
            out: &mut out,
            parent: Default::default(),
            example: Default::default(),
            flat: Default::default(),
            inline: Default::default(),
            depth: Default::default(),
        }
        .print();

        out.render()
    }
}