GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-09-24 16:56:36 -04:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

Rename ParseErrorKind to SearchErrorKind

Browse source
This commit is contained in:
RumovZ 2021-01-14 22:00:52 +01:00
parent 6af1852611
commit 5f05ca2548
2 changed files with 38 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
rslib/src/err.rs
View file

@ -60,7 +60,7 @@ pub enum AnkiError {
DeckIsFiltered,
#[fail(display = "Invalid search.")]
SearchError(ParseErrorKind),
SearchError(SearchErrorKind),
}
// error helpers
@ -121,34 +121,34 @@ impl AnkiError {
_ => format!("{:?}", self),
},
AnkiError::SearchError(kind) => match kind {
ParseErrorKind::MisplacedAnd => i18n.tr(TR::SearchMisplacedAnd),
ParseErrorKind::MisplacedOr => i18n.tr(TR::SearchMisplacedOr),
ParseErrorKind::EmptyGroup => i18n.tr(TR::SearchEmptyGroup),
ParseErrorKind::UnopenedGroup => i18n.tr(TR::SearchUnopenedGroup),
ParseErrorKind::UnclosedGroup => i18n.tr(TR::SearchUnclosedGroup),
ParseErrorKind::EmptyQuote => i18n.tr(TR::SearchEmptyQuote),
ParseErrorKind::UnclosedQuote => i18n.tr(TR::SearchUnclosedQuote),
ParseErrorKind::MissingKey => i18n.tr(TR::SearchMissingKey),
ParseErrorKind::UnknownEscape(_seq) => i18n.tr(TR::SearchUnknownEscape),
ParseErrorKind::InvalidIdList => i18n.tr(TR::SearchInvalidIdList),
ParseErrorKind::InvalidState => i18n.tr(TR::SearchInvalidState),
ParseErrorKind::InvalidFlag => i18n.tr(TR::SearchInvalidFlag),
ParseErrorKind::InvalidAdded => i18n.tr(TR::SearchInvalidAdded),
ParseErrorKind::InvalidEdited => i18n.tr(TR::SearchInvalidEdited),
ParseErrorKind::InvalidRatedDays => i18n.tr(TR::SearchInvalidRatedDays),
ParseErrorKind::InvalidRatedEase => i18n.tr(TR::SearchInvalidRatedEase),
ParseErrorKind::InvalidDupeMid => i18n.tr(TR::SearchInvalidDupeMid),
ParseErrorKind::InvalidDupeText => i18n.tr(TR::SearchInvalidDupeText),
ParseErrorKind::InvalidPropProperty => i18n.tr(TR::SearchInvalidPropProperty),
ParseErrorKind::InvalidPropOperator => i18n.tr(TR::SearchInvalidPropOperator),
ParseErrorKind::InvalidPropFloat => i18n.tr(TR::SearchInvalidPropFloat),
ParseErrorKind::InvalidPropInteger => i18n.tr(TR::SearchInvalidPropInteger),
ParseErrorKind::InvalidPropUnsigned => i18n.tr(TR::SearchInvalidPropUnsigned),
ParseErrorKind::InvalidDid => i18n.tr(TR::SearchInvalidDid),
ParseErrorKind::InvalidMid => i18n.tr(TR::SearchInvalidMid),
ParseErrorKind::Regex(text) => text.into(),
ParseErrorKind::Other(Some(info)) => info.into(),
ParseErrorKind::Other(None) => i18n.tr(TR::SearchInvalid),
SearchErrorKind::MisplacedAnd => i18n.tr(TR::SearchMisplacedAnd),
SearchErrorKind::MisplacedOr => i18n.tr(TR::SearchMisplacedOr),
SearchErrorKind::EmptyGroup => i18n.tr(TR::SearchEmptyGroup),
SearchErrorKind::UnopenedGroup => i18n.tr(TR::SearchUnopenedGroup),
SearchErrorKind::UnclosedGroup => i18n.tr(TR::SearchUnclosedGroup),
SearchErrorKind::EmptyQuote => i18n.tr(TR::SearchEmptyQuote),
SearchErrorKind::UnclosedQuote => i18n.tr(TR::SearchUnclosedQuote),
SearchErrorKind::MissingKey => i18n.tr(TR::SearchMissingKey),
SearchErrorKind::UnknownEscape(_seq) => i18n.tr(TR::SearchUnknownEscape),
SearchErrorKind::InvalidIdList => i18n.tr(TR::SearchInvalidIdList),
SearchErrorKind::InvalidState => i18n.tr(TR::SearchInvalidState),
SearchErrorKind::InvalidFlag => i18n.tr(TR::SearchInvalidFlag),
SearchErrorKind::InvalidAdded => i18n.tr(TR::SearchInvalidAdded),
SearchErrorKind::InvalidEdited => i18n.tr(TR::SearchInvalidEdited),
SearchErrorKind::InvalidRatedDays => i18n.tr(TR::SearchInvalidRatedDays),
SearchErrorKind::InvalidRatedEase => i18n.tr(TR::SearchInvalidRatedEase),
SearchErrorKind::InvalidDupeMid => i18n.tr(TR::SearchInvalidDupeMid),
SearchErrorKind::InvalidDupeText => i18n.tr(TR::SearchInvalidDupeText),
SearchErrorKind::InvalidPropProperty => i18n.tr(TR::SearchInvalidPropProperty),
SearchErrorKind::InvalidPropOperator => i18n.tr(TR::SearchInvalidPropOperator),
SearchErrorKind::InvalidPropFloat => i18n.tr(TR::SearchInvalidPropFloat),
SearchErrorKind::InvalidPropInteger => i18n.tr(TR::SearchInvalidPropInteger),
SearchErrorKind::InvalidPropUnsigned => i18n.tr(TR::SearchInvalidPropUnsigned),
SearchErrorKind::InvalidDid => i18n.tr(TR::SearchInvalidDid),
SearchErrorKind::InvalidMid => i18n.tr(TR::SearchInvalidMid),
SearchErrorKind::Regex(text) => text.into(),
SearchErrorKind::Other(Some(info)) => info.into(),
SearchErrorKind::Other(None) => i18n.tr(TR::SearchInvalid),
}
.into(),
_ => format!("{:?}", self),
@ -188,7 +188,7 @@ impl From<rusqlite::Error> for AnkiError {
};
}
if reason.contains("regex parse error") {
return AnkiError::SearchError(ParseErrorKind::Regex(reason.to_owned()));
return AnkiError::SearchError(SearchErrorKind::Regex(reason.to_owned()));
}
}
AnkiError::DBError {
@ -355,12 +355,12 @@ pub enum DBErrorKind {
#[derive(Debug, PartialEq)]
pub enum ParseError<'a> {
Anki(&'a str, ParseErrorKind),
Anki(&'a str, SearchErrorKind),
Nom(&'a str, NomErrorKind),
}
#[derive(Debug, PartialEq)]
pub enum ParseErrorKind {
pub enum SearchErrorKind {
MisplacedAnd,
MisplacedOr,
EmptyGroup,
@ -394,7 +394,7 @@ impl From<ParseError<'_>> for AnkiError {
fn from(err: ParseError) -> Self {
match err {
ParseError::Anki(_, kind) => AnkiError::SearchError(kind),
ParseError::Nom(_, _) => AnkiError::SearchError(ParseErrorKind::Other(None)),
ParseError::Nom(_, _) => AnkiError::SearchError(SearchErrorKind::Other(None)),
}
}
}
@ -404,7 +404,7 @@ impl From<nom::Err<ParseError<'_>>> for AnkiError {
match err {
nom::Err::Error(e) => e.into(),
nom::Err::Failure(e) => e.into(),
nom::Err::Incomplete(_) => AnkiError::SearchError(ParseErrorKind::Other(None)),
nom::Err::Incomplete(_) => AnkiError::SearchError(SearchErrorKind::Other(None)),
}
}
}

6
rslib/src/search/parser.rs
View file

@ -3,7 +3,7 @@
use crate::{
decks::DeckID,
err::{ParseError, ParseErrorKind as FailKind, Result},
err::{ParseError, SearchErrorKind as FailKind, Result},
notetype::NoteTypeID,
};
use lazy_static::lazy_static;
@ -116,12 +116,14 @@ pub(super) fn parse(input: &str) -> Result<Vec<Node>> {
match group_inner(input) {
Ok(("", nodes)) => Ok(nodes),
// unmatched ) is only char not consumed by any node parser
Ok((remaining, _)) => Err(parse_failure(remaining, FailKind::UnopenedGroup).into()),
Err(err) => Err(err.into()),
}
}
/// One or more nodes inside brackets, er 'one OR two -three'
/// Zero or more nodes inside brackets, eg 'one OR two -three'.
/// Empty vec must be handled by caller.
fn group_inner(input: &str) -> IResult<Vec<Node>> {
let mut remaining = input;
let mut nodes = vec![];