somedoc 0.2.10

A very simple document model and markup generator.
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

use crate::model::block::{Caption, HasCaption, Label};
use crate::model::inline::InlineContent;
#[cfg(feature = "fmt_json")]
use serde::{Deserialize, Serialize};

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

///
/// The target types used by the `target` field of `HyperLink`.
///
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "fmt_json", derive(Serialize, Deserialize))]
pub enum HyperLinkTarget {
    /// The target is an external reference, i.e. URL.
    External(String),
    /// The target is an internal reference, a `Label` on some element.
    Internal(Label),
}

///
/// A link to another document, or an intra-document reference.
///
#[derive(Clone, Debug)]
#[cfg_attr(feature = "fmt_json", derive(Serialize, Deserialize))]
pub struct HyperLink {
    target: HyperLinkTarget,
    #[cfg_attr(feature = "fmt_json", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "fmt_json", serde(default))]
    caption: Option<Caption>,
}

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

impl From<Label> for HyperLink {
    fn from(v: Label) -> Self {
        Self::internal(v)
    }
}

impl From<HyperLinkTarget> for HyperLink {
    fn from(v: HyperLinkTarget) -> Self {
        Self {
            target: v,
            caption: None,
        }
    }
}

inline_impls!(HyperLink);

has_captioned_impls!(HyperLink);

impl HyperLink {
    /// Create a new `Link` with `target` an external location.
    pub fn external(target: &str) -> Self {
        Self::new_external(target, None)
    }

    /// Create a new `Link` with `target` an external location, and associated caption.
    pub fn external_with_caption(target: &str, caption: Caption) -> Self {
        Self::new_external(target, Some(caption))
    }

    /// Create a new `Link` with `target` an external location, and associated caption string.
    pub fn external_with_caption_str(target: &str, caption: &str) -> Self {
        Self::new_external(target, Some(caption.into()))
    }

    /// Create a new `Link` with `target` an internal location.
    pub fn internal(target: Label) -> Self {
        Self::new_internal(target, None)
    }

    /// Create a new `Link` with `target` an internal location, and associated caption.
    pub fn internal_with_caption(target: Label, caption: Caption) -> Self {
        Self::new_internal(target, Some(caption))
    }

    /// Create a new `Link` with `target` an internal location, and associated caption string.
    pub fn internal_with_caption_str(target: Label, caption: &str) -> Self {
        Self::new_internal(target, Some(caption.into()))
    }

    fn new_external(target: &str, caption: Option<Caption>) -> Self {
        Self {
            target: HyperLinkTarget::External(target.to_string()),
            caption,
        }
    }

    fn new_internal(target: Label, caption: Option<Caption>) -> Self {
        Self {
            target: HyperLinkTarget::Internal(target),
            caption,
        }
    }

    // --------------------------------------------------------------------------------------------

    /// Is the target of this link internal?
    pub fn is_internal(&self) -> bool {
        matches!(&self.target, HyperLinkTarget::Internal(_))
    }

    /// Is the target of this link external?
    pub fn is_external(&self) -> bool {
        matches!(&self.target, HyperLinkTarget::External(_))
    }

    // --------------------------------------------------------------------------------------------

    /// Return the target of this link.
    pub fn target(&self) -> &HyperLinkTarget {
        &self.target
    }
}