acdc-parser 0.9.0

`AsciiDoc` parser using PEG grammars
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
138
139
140
141
142
143
144
145
146

use std::ops::Deref;

use serde::{Serialize, ser::Serializer};

use super::inlines::InlineNode;

/// An attribution in a blockquote (the author/source of the quote).
///
/// `Attribution` is a newtype wrapper around `Vec<InlineNode>` that provides
/// convenient access to inline content. Attributions can include formatting,
/// links, and other inline elements.
///
/// # Serialization
///
/// Serializes as a plain JSON array of inline nodes.
#[derive(Clone, Debug, Default, PartialEq)]
#[non_exhaustive]
pub struct Attribution<'a>(Vec<InlineNode<'a>>);

impl Serialize for Attribution<'_> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        self.0.serialize(serializer)
    }
}

impl<'a> Attribution<'a> {
    /// Creates a new `Attribution` with the given inline content.
    #[must_use]
    pub fn new(inlines: Vec<InlineNode<'a>>) -> Self {
        Self(inlines)
    }

    /// Returns `true` if the attribution has no content.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Returns the number of inline nodes in the attribution.
    #[must_use]
    pub fn len(&self) -> usize {
        self.0.len()
    }
}

impl<'a> From<Vec<InlineNode<'a>>> for Attribution<'a> {
    fn from(inlines: Vec<InlineNode<'a>>) -> Self {
        Self(inlines)
    }
}

impl<'a> AsRef<[InlineNode<'a>]> for Attribution<'a> {
    fn as_ref(&self) -> &[InlineNode<'a>] {
        &self.0
    }
}

impl<'a> Deref for Attribution<'a> {
    type Target = [InlineNode<'a>];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'a, 'b> IntoIterator for &'b Attribution<'a> {
    type Item = &'b InlineNode<'a>;
    type IntoIter = std::slice::Iter<'b, InlineNode<'a>>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter()
    }
}

/// A citation title in a blockquote (the title of the cited work).
///
/// `CiteTitle` is a newtype wrapper around `Vec<InlineNode>` that provides
/// convenient access to inline content.
///
/// # Serialization
///
/// Serializes as a plain JSON array of inline nodes.
#[derive(Clone, Debug, Default, PartialEq)]
#[non_exhaustive]
pub struct CiteTitle<'a>(Vec<InlineNode<'a>>);

impl Serialize for CiteTitle<'_> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        self.0.serialize(serializer)
    }
}

impl<'a> CiteTitle<'a> {
    /// Creates a new `CiteTitle` with the given inline content.
    #[must_use]
    pub fn new(inlines: Vec<InlineNode<'a>>) -> Self {
        Self(inlines)
    }

    /// Returns `true` if the cite title has no content.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Returns the number of inline nodes in the cite title.
    #[must_use]
    pub fn len(&self) -> usize {
        self.0.len()
    }
}

impl<'a> From<Vec<InlineNode<'a>>> for CiteTitle<'a> {
    fn from(inlines: Vec<InlineNode<'a>>) -> Self {
        Self(inlines)
    }
}

impl<'a> AsRef<[InlineNode<'a>]> for CiteTitle<'a> {
    fn as_ref(&self) -> &[InlineNode<'a>] {
        &self.0
    }
}

impl<'a> Deref for CiteTitle<'a> {
    type Target = [InlineNode<'a>];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'a, 'b> IntoIterator for &'b CiteTitle<'a> {
    type Item = &'b InlineNode<'a>;
    type IntoIter = std::slice::Iter<'b, InlineNode<'a>>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter()
    }
}