source-text 0.1.0

Process &str from either a file or in-memory string w/ the source in help context.
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

use crate::Source;

/// An [OwnedSource] owns a `text` string with an optional `name` denoting the origin.
#[derive(Debug)]
pub struct OwnedSource {
    name: Option<String>,
    text: String,
}

impl OwnedSource {
    /// Create a new [OwnedSource] with an optional origin name. Example: `OwnedSource::new(Some("<built-in>"), "my text")`
    pub fn new<N, T>(optname: Option<N>, text: T) -> Self
    where
        String: From<N>,
        String: From<T>,
    {
        OwnedSource {
            name: optname.map(|n| String::from(n)),
            text: String::from(text),
        }
    }

    /// Create a new [OwnedSource] with a given origin name. Example: `OwnedSource::new_named("<built-in>", "my text")`
    pub fn new_named<N, T>(name: N, text: T) -> Self
    where
        String: From<N>,
        String: From<T>,
    {
        OwnedSource::new(Some(name), text)
    }

    /// Create a new [OwnedSource] without an origin name. Example: `Source::new_unnamed("my text")`
    pub fn new_unnamed<T>(text: T) -> Self
    where
        String: From<T>,
    {
        OwnedSource::new(None, text)
    }

    /// Borrow the name, which if absent defaults to `"<string>"`.
    pub fn name(&self) -> &str {
        use crate::optname_to_str;

        optname_to_str(self.name.as_ref().map(|s| s.as_ref()))
    }

    /// Borrow the text.
    pub fn text(&self) -> &str {
        self.text.as_ref()
    }

    /// Return a [Source] referring to `self`'s contents.
    pub fn source(&self) -> Source {
        Source::new(self.name.as_ref(), self.text())
    }

    /// Unbundle the optional `name` and `text` to take direct ownership.
    pub fn unwrap(self) -> (Option<String>, String) {
        (self.name, self.text)
    }
}