use crate::error::{ParseError, Reason};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Token<'a> {
Key(&'a str),
Value(&'a str),
Equals,
All,
Any,
Not,
OpenParen,
CloseParen,
Comma,
}
impl<'a> std::fmt::Display for Token<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Debug::fmt(self, f)
}
}
impl<'a> Token<'a> {
fn len(&self) -> usize {
match self {
Token::Key(s) => s.len(),
Token::Value(s) => s.len() + 2,
Token::Equals | Token::OpenParen | Token::CloseParen | Token::Comma => 1,
Token::All | Token::Any | Token::Not => 3,
}
}
}
pub struct Lexer<'a> {
pub(super) inner: &'a str,
original: &'a str,
offset: usize,
}
impl<'a> Lexer<'a> {
pub fn new(text: &'a str) -> Self {
let text = if text.starts_with("cfg(") && text.ends_with(')') {
&text[4..text.len() - 1]
} else {
text
};
Self {
inner: text,
original: text,
offset: 0,
}
}
}
#[derive(Debug)]
pub struct LexerToken<'a> {
pub token: Token<'a>,
pub span: std::ops::Range<usize>,
}
impl<'a> Iterator for Lexer<'a> {
type Item = Result<LexerToken<'a>, ParseError>;
fn next(&mut self) -> Option<Self::Item> {
let non_whitespace_index = match self.inner.find(|c: char| !c.is_whitespace()) {
Some(idx) => idx,
None => self.inner.len(),
};
self.inner = &self.inner[non_whitespace_index..];
self.offset += non_whitespace_index;
#[inline]
fn is_ident_start(ch: char) -> bool {
ch == '_' || (('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch))
}
#[inline]
fn is_ident_rest(ch: char) -> bool {
is_ident_start(ch) || ('0'..='9').contains(&ch)
}
match self.inner.chars().next() {
None => None,
Some('=') => Some(Ok(Token::Equals)),
Some('(') => Some(Ok(Token::OpenParen)),
Some(')') => Some(Ok(Token::CloseParen)),
Some(',') => Some(Ok(Token::Comma)),
Some(c) => {
if c == '"' {
match self.inner[1..].find('"') {
Some(ind) => Some(Ok(Token::Value(&self.inner[1..=ind]))),
None => Some(Err(ParseError {
original: self.original.to_owned(),
span: self.offset..self.original.len(),
reason: Reason::UnclosedQuotes,
})),
}
} else if is_ident_start(c) {
let substr = match self.inner[1..].find(|c: char| !is_ident_rest(c)) {
Some(ind) => &self.inner[..=ind],
None => self.inner,
};
match substr {
"all" => Some(Ok(Token::All)),
"any" => Some(Ok(Token::Any)),
"not" => Some(Ok(Token::Not)),
other => Some(Ok(Token::Key(other))),
}
} else {
#[allow(clippy::range_plus_one)]
Some(Err(ParseError {
original: self.original.to_owned(),
span: self.offset..self.offset + 1,
reason: Reason::Unexpected(&["<key>", "all", "any", "not"]),
}))
}
}
}
.map(|tok| {
tok.map(|tok| {
let len = tok.len();
let start = self.offset;
self.inner = &self.inner[len..];
self.offset += len;
LexerToken {
token: tok,
span: start..self.offset,
}
})
})
}
}