mirror-github-bspeice/dtparse
1
0
Fork 0
mirror of https://github.com/bspeice/dtparse synced 2025-04-03 04:21:31 -04:00
Code Issues Releases Wiki Activity

fix clippy err

Browse Source
This commit is contained in:
taichong 2024-07-16 22:31:24 +08:00
parent 5a0b0358b1
commit 7cfd18211d
3 changed files with 23 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/lib.rs
View File

@ -174,7 +174,7 @@ pub fn parse_info(vec: Vec<Vec<&str>>) -> HashMap<String, usize> {
let mut m = HashMap::new();
if vec.len() == 1 {
for (i, val) in vec.get(0).unwrap().iter().enumerate() {
for (i, val) in vec.first().unwrap().iter().enumerate() {
m.insert(val.to_lowercase(), i);
}
} else {
@ -305,13 +305,9 @@ impl ParserInfo {
}
fn ampm_index(&self, name: &str) -> Option<bool> {
if let Some(v) = self.ampm.get(&name.to_lowercase()) {
// Python technically uses numbers here, but given that the numbers are
// only 0 and 1, it's easier to use booleans
Some(*v == 1)
} else {
None
}
// Python technically uses numbers here, but given that the numbers are
// only 0 and 1, it's easier to use booleans
self.ampm.get(&name.to_lowercase()).map(|v| *v == 1)
}
fn pertain_index(&self, name: &str) -> bool {
@ -394,6 +390,7 @@ enum YMDLabel {
Day,
}
#[allow(clippy::upper_case_acronyms)]
#[derive(Debug, Default)]
struct YMD {
_ymd: Vec<i32>, // TODO: This seems like a super weird way to store things
@ -412,7 +409,7 @@ impl YMD {
if self.dstridx.is_some() {
false
} else if self.mstridx.is_none() {
(1 <= val) && (val <= 31)
(1..=31).contains(&val)
} else if self.ystridx.is_none() {
// UNWRAP: Earlier condition catches mstridx missing
let month = self._ymd[self.mstridx.unwrap()];
@ -759,7 +756,7 @@ impl Parser {
let mut res = ParsingResult::default();
let mut l = tokenize(&timestr);
let mut l = tokenize(timestr);
let mut skipped_idxs: Vec<usize> = Vec::new();
let mut ymd = YMD::default();
@ -978,7 +975,7 @@ impl Parser {
days_in_month(y, m as i32)?,
),
)
.ok_or_else(|| ParseError::ImpossibleTimestamp("Invalid date range given"))?;
.ok_or(ParseError::ImpossibleTimestamp("Invalid date range given"))?;
let d = d + d_offset;
@ -1014,11 +1011,11 @@ impl Parser {
) -> ParseResult<Option<FixedOffset>> {
if let Some(offset) = res.tzoffset {
Ok(FixedOffset::east_opt(offset))
} else if res.tzoffset == None
} else if res.tzoffset.is_none()
&& (res.tzname == Some(" ".to_owned())
|| res.tzname == Some(".".to_owned())
|| res.tzname == Some("-".to_owned())
|| res.tzname == None)
|| res.tzname.is_none())
{
Ok(None)
} else if res.tzname.is_some() && tzinfos.contains_key(res.tzname.as_ref().unwrap()) {
@ -1045,7 +1042,7 @@ impl Parser {
) -> ParseResult<usize> {
let mut idx = idx;
let value_repr = &tokens[idx];
let mut value = Decimal::from_str(&value_repr).unwrap();
let mut value = Decimal::from_str(value_repr).unwrap();
let len_li = value_repr.len();
let len_l = tokens.len();
@ -1069,7 +1066,7 @@ impl Parser {
// YYMMDD or HHMMSS[.ss]
let s = &tokens[idx];
if ymd.len() == 0 && tokens[idx].find('.') == None {
if ymd.len() == 0 && tokens[idx].find('.').is_none() {
ymd.append(s[0..2].parse::<i32>()?, &s[0..2], None)?;
ymd.append(s[2..4].parse::<i32>()?, &s[2..4], None)?;
ymd.append(s[4..6].parse::<i32>()?, &s[4..6], None)?;
@ -1082,7 +1079,7 @@ impl Parser {
res.second = Some(t.0);
res.nanosecond = Some(t.1);
}
} else if vec![8, 12, 14].contains(&len_li) {
} else if [8, 12, 14].contains(&len_li) {
// YYMMDD
let s = &tokens[idx];
ymd.append(s[..4].parse::<i32>()?, &s[..4], Some(YMDLabel::Year))?;
@ -1128,7 +1125,7 @@ impl Parser {
{
// TODO: There's got to be a better way of handling the condition above
let sep = &tokens[idx + 1];
ymd.append(value_repr.parse::<i32>()?, &value_repr, None)?;
ymd.append(value_repr.parse::<i32>()?, value_repr, None)?;
if idx + 2 < len_l && !info.jump_index(&tokens[idx + 2]) {
if let Ok(val) = tokens[idx + 2].parse::<i32>() {
@ -1165,7 +1162,7 @@ impl Parser {
.floor()
.to_i32()
.ok_or_else(|| ParseError::InvalidNumeric(value_repr.to_owned()))?;
ymd.append(value, &value_repr, None)?;
ymd.append(value, value_repr, None)?;
}
idx += 1;
@ -1177,7 +1174,7 @@ impl Parser {
res.hour = Some(self.adjust_ampm(hour, info.ampm_index(&tokens[idx + 1]).unwrap()));
idx += 1;
} else if ymd.could_be_day(value.to_i64().unwrap() as i32) {
ymd.append(value.to_i64().unwrap() as i32, &value_repr, None)?;
ymd.append(value.to_i64().unwrap() as i32, value_repr, None)?;
} else if !fuzzy {
return Err(ParseError::UnrecognizedFormat);
}
@ -1300,7 +1297,7 @@ impl Parser {
}
fn to_decimal(&self, value: &str) -> ParseResult<Decimal> {
Decimal::from_str(value).or_else(|_| Err(ParseError::InvalidNumeric(value.to_owned())))
Decimal::from_str(value).map_err(|_| ParseError::InvalidNumeric(value.to_owned()))
}
fn parse_min_sec(&self, value: Decimal) -> (i32, Option<i32>) {

8
src/tests/pycompat_parser.rs
View File

@ -25,6 +25,7 @@ struct PyDateTime {
tzo: Option<i32>,
}
#[allow(clippy::too_many_arguments)]
fn parse_and_assert(
pdt: PyDateTime,
info: ParserInfo,
@ -49,7 +50,7 @@ fn parse_and_assert(
ignoretz,
tzinfos,
)
.expect(&format!("Unable to parse date in Rust '{}'", s));
.unwrap_or_else(|_| panic!("Unable to parse date in Rust '{}'", s));
assert_eq!(pdt.year, rs_parsed.0.year(), "Year mismatch for '{}'", s);
assert_eq!(pdt.month, rs_parsed.0.month(), "Month mismatch for '{}'", s);
@ -82,7 +83,7 @@ fn parse_and_assert(
}
fn parse_and_assert_simple(pdt: PyDateTime, s: &str) {
let rs_parsed = parse(s).expect(&format!("Unable to parse date in Rust '{}'", s));
let rs_parsed = parse(s).unwrap_or_else(|_| panic!("Unable to parse date in Rust '{}'", s));
assert_eq!(pdt.year, rs_parsed.0.year(), "Year mismatch for '{}'", s);
assert_eq!(pdt.month, rs_parsed.0.month(), "Month mismatch for '{}'", s);
assert_eq!(pdt.day, rs_parsed.0.day(), "Day mismatch for '{}'", s);
@ -113,6 +114,7 @@ fn parse_and_assert_simple(pdt: PyDateTime, s: &str) {
);
}
#[allow(clippy::too_many_arguments)]
fn parse_fuzzy_and_assert(
pdt: PyDateTime,
ptokens: Option<Vec<String>>,
@ -138,7 +140,7 @@ fn parse_fuzzy_and_assert(
ignoretz,
tzinfos,
)
.expect(&format!("Unable to parse date in Rust '{}'", s));
.unwrap_or_else(|_| panic!("Unable to parse date in Rust '{}'", s));
assert_eq!(pdt.year, rs_parsed.0.year(), "Year mismatch for '{}'", s);
assert_eq!(pdt.month, rs_parsed.0.month(), "Month mismatch for '{}'", s);

2
src/weekday.rs
View File

@ -55,7 +55,7 @@ impl DayOfWeek {
pub fn day_of_week(year: u32, month: u32, day: u32) -> ParseResult<DayOfWeek> {
// From https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Schwerdtfeger's_method
let (c, g) = match month {
3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 => {
3..=12 => {
let c = year / 100;
(c, year - 100 * c)
}