ara_source 0.2.0

A Source library for Ara Programming Language 🗃
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

pub const DEFAULT_NAME: &str = "<unknown>";

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum SourceKind {
    /// A definition is a piece of code that is not executed, but can be used
    /// to define foriegn symbols ( e.g from PHP ).
    Definition,

    /// A script is a piece of code that is executed.
    Script,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Source {
    pub kind: SourceKind,
    pub origin: Option<String>,
    pub content: String,
}

/// A source.
///
/// A source is a reference to a piece of code.
///
/// Example:
///
/// ```rust
/// use ara_source::source::Source;
/// use ara_source::source::SourceKind;
///
/// let source = Source::new(SourceKind::Script, "main.ara", "function main(): void {}");
///
/// assert_eq!(source.kind, SourceKind::Script);
/// assert_eq!(source.origin, Some("main.ara".to_string()));
/// assert_eq!(source.content, "function main(): void {}");
///
/// assert_eq!(source.name(), "main.ara");
/// ```
impl Source {
    /// Create a new source with the given content.
    ///
    /// Example:
    ///
    /// ```rust
    /// use ara_source::source::Source;
    /// use ara_source::source::SourceKind;
    ///
    /// let source = Source::inline(SourceKind::Definition, "function main(): void {}");
    ///
    /// assert_eq!(source.kind, SourceKind::Definition);
    /// assert_eq!(source.origin, None);
    /// assert_eq!(source.content, "function main(): void {}");
    ///
    /// assert_eq!(source.name(), "<unknown>");
    /// ```
    pub fn new<O: Into<String>, C: Into<String>>(
        kind: SourceKind,
        origin: O,
        content: C,
    ) -> Source {
        Source {
            kind,
            origin: Some(origin.into()),
            content: content.into(),
        }
    }

    /// Create a new source with the given content.
    ///
    /// Example:
    ///
    /// ```rust
    /// use ara_source::source::Source;
    /// use ara_source::source::SourceKind;
    ///
    /// let source = Source::inline(SourceKind::Definition, "function main(): void {}");
    ///
    /// assert_eq!(source.kind, SourceKind::Definition);
    /// assert_eq!(source.origin, None);
    /// assert_eq!(source.content, "function main(): void {}");
    /// ```
    pub fn inline<C: Into<String>>(kind: SourceKind, content: C) -> Source {
        Source {
            kind,
            origin: None,
            content: content.into(),
        }
    }

    /// Get the name of the source.
    ///
    /// If the source has an origin, the origin is returned.
    /// Otherwise, the default name is returned.
    ///
    /// Example:
    ///
    /// ```rust
    /// use ara_source::source::Source;
    /// use ara_source::source::SourceKind;
    ///
    /// let source = Source::new(SourceKind::Definition, "main.ara", "function main(): void {}");
    /// assert_eq!(source.name(), "main.ara");
    ///
    /// let source = Source::inline(SourceKind::Definition, "function main(): void {}");
    /// assert_eq!(source.name(), "<unknown>");
    /// ```
    pub fn name(&self) -> &str {
        match self.origin {
            Some(ref origin) => origin,
            None => DEFAULT_NAME,
        }
    }
}