nixel 5.2.0

Parser for the Nix Expressions 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
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
147
148

// SPDX-FileCopyrightText: 2022 Kevin Amado <kamadorueda@gmail.com>
//
// SPDX-License-Identifier: GPL-3.0-only

use crate::mem::own;
use crate::mem::own_str;

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// `${expression}`.
pub struct PartExpression {
    pub expression: Box<crate::Expression>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// `"${expression}"`.
pub struct PartInterpolation {
    pub expression: Box<crate::Expression>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// `"content"`.
pub struct PartRaw {
    pub content: Box<str>,
    pub span: Box<crate::Span>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// `Expression`, `Interpolation`, or `Raw`.
pub enum Part {
    Expression(PartExpression),
    Interpolation(PartInterpolation),
    Raw(PartRaw),
}

impl Part {
    pub fn span(&self) -> crate::Span {
        match self {
            Self::Expression(expression) => expression.expression.span(),
            Self::Interpolation(interpolation) => {
                interpolation.expression.span()
            },
            Self::Raw(raw) => raw.span.as_ref().clone(),
        }
    }

    pub fn start(&self) -> crate::Position {
        match self {
            Self::Expression(expression) => expression.expression.start(),
            Self::Interpolation(interpolation) => {
                interpolation.expression.start()
            },
            Self::Raw(raw) => raw.span.start.as_ref().clone(),
        }
    }

    pub fn end(&self) -> crate::Position {
        match self {
            Self::Expression(expression) => expression.expression.end(),
            Self::Interpolation(interpolation) => {
                interpolation.expression.end()
            },
            Self::Raw(raw) => raw.span.end.as_ref().clone(),
        }
    }
}

impl std::convert::From<*mut crate::ffi::Part> for Part {
    fn from(part: *mut crate::ffi::Part) -> Self {
        let crate::ffi::Part { kind, ptr } = own(part);

        match kind {
            crate::ffi::PartKind_PartKindExpression => {
                let expression: crate::ffi::Expression = own(ptr);

                Self::Expression(PartExpression {
                    expression: Box::new(crate::Expression::from(expression)),
                })
            },
            crate::ffi::PartKind_PartKindInterpolation => {
                let expression: crate::ffi::Expression = own(ptr);

                Self::Interpolation(PartInterpolation {
                    expression: Box::new(crate::Expression::from(expression)),
                })
            },
            crate::ffi::PartKind_PartKindRaw => {
                let crate::ffi::PartRaw { content, span } = own(ptr);
                let crate::ffi::UtilString { content, should_unescape } =
                    own(content);
                let content = own_str(content);

                Self::Raw(PartRaw {
                    content: if should_unescape {
                        unescape(&content)
                    } else {
                        content
                    },
                    span: Box::new(crate::Span::from(span)),
                })
            },
            _ => unreachable!(),
        }
    }
}

fn unescape(content: &str) -> Box<str> {
    let mut input_chars = content.chars().peekable();
    let mut output = String::new();

    loop {
        let input_char = input_chars.next();

        if input_char.is_none() {
            break;
        }

        let mut input_char = input_char.unwrap();

        match input_char {
            '\\' => {
                input_char = input_chars.next().unwrap();

                if input_char == 'n' {
                    output.push('\n');
                } else if input_char == 'r' {
                    output.push('\r');
                } else if input_char == 't' {
                    output.push('\t');
                } else {
                    output.push(input_char);
                }
            },
            '\r' => {
                output.push('\n');
                input_chars.next_if(|s| *s == '\n');
            },
            c => {
                output.push(c);
            },
        }
    }

    output.into_boxed_str()
}