From 6ac1ef0ca50d9703a0b36f278862433a2dc12103 Mon Sep 17 00:00:00 2001
From: Christopher Serr <christopher.serr@gmail.com>
Date: Sun, 15 Sep 2024 18:09:04 +0200
Subject: [PATCH] Support the new JSON based Flitter splits files (#841)

Flitter got rewritten in Rust and the splits files are now JSON based.
This adds support for parsing those files. The old file format is no
longer supported, because Flitter itself also no longer supports it.

This also changes how we parse time spans in general, making them more
strict in what they accept. Previously ridiculous values like
`100:100:100:100:100` got accepted.
---
 src/run/parser/flitter.rs               | 134 ++++++++
 src/run/parser/flitter/mod.rs           |  78 -----
 src/run/parser/flitter/s_expressions.rs | 419 ------------------------
 src/settings/layout_background.rs       |   2 +-
 src/timing/mod.rs                       |   2 +
 src/timing/time_span.rs                 | 182 +++++++---
 src/util/ascii_char.rs                  |  27 +-
 tests/run_files/flitter.json            |  81 +++++
 tests/run_files/mod.rs                  |   3 +-
 tests/split_parsing.rs                  |   8 -
 10 files changed, 359 insertions(+), 577 deletions(-)
 create mode 100644 src/run/parser/flitter.rs
 delete mode 100644 src/run/parser/flitter/mod.rs
 delete mode 100644 src/run/parser/flitter/s_expressions.rs
 create mode 100644 tests/run_files/flitter.json

diff --git a/src/run/parser/flitter.rs b/src/run/parser/flitter.rs
new file mode 100644
index 00000000..d9af8f10
--- /dev/null
+++ b/src/run/parser/flitter.rs
@@ -0,0 +1,134 @@
+//! Provides the parser for Flitter splits files.
+
+use crate::{
+    platform::prelude::*,
+    timing::{parse_custom, CustomParser},
+    Run, Segment, Time,
+};
+use alloc::borrow::Cow;
+use core::result::Result as StdResult;
+use serde_derive::Deserialize;
+use serde_json::Error as JsonError;
+use snafu::ensure;
+
+/// The Error type for splits files that couldn't be parsed by the Flitter
+/// Parser.
+#[derive(Debug, snafu::Snafu)]
+#[snafu(context(suffix(false)))]
+pub enum Error {
+    /// Failed to parse JSON.
+    Json {
+        /// The underlying error.
+        #[cfg_attr(not(feature = "std"), snafu(source(false)))]
+        source: JsonError,
+    },
+    /// The split names can't be empty.
+    SplitNamesEmpty,
+    /// The personal best can't be empty.
+    PersonalBestEmpty,
+    /// The golds can't be empty.
+    GoldsEmpty,
+    /// The split name count does not match the gold count.
+    GoldCountMismatch,
+    /// The split name count does not match the personal best split count.
+    PersonalBestCountMismatch,
+    /// The last split of the personal best can't be null.
+    LastSplitNull,
+}
+
+/// The Result type for the Flitter Parser.
+pub type Result<T> = StdResult<T, Error>;
+
+#[derive(Deserialize)]
+struct Splits<'a> {
+    #[serde(borrow)]
+    title: Cow<'a, str>,
+    #[serde(borrow)]
+    category: Cow<'a, str>,
+    attempts: u32,
+    // completed: u32,
+    #[serde(borrow)]
+    split_names: Vec<Cow<'a, str>>,
+    #[serde(borrow)]
+    golds: Vec<Option<Gold<'a>>>,
+    #[serde(borrow)]
+    personal_best: PersonalBest<'a>,
+}
+
+#[derive(Deserialize)]
+struct Gold<'a> {
+    #[serde(borrow)]
+    duration: Cow<'a, str>,
+}
+
+#[derive(Deserialize)]
+struct PersonalBest<'a> {
+    // attempt: u32,
+    #[serde(borrow)]
+    splits: Vec<Option<Split<'a>>>,
+}
+
+#[derive(Deserialize)]
+struct Split<'a> {
+    #[serde(borrow)]
+    time: Cow<'a, str>,
+}
+
+struct FlitterParser;
+
+impl CustomParser for FlitterParser {
+    const ASCII_ONLY: bool = true;
+    const ALLOW_NEGATIVE: bool = false;
+    const WITH_DAYS: bool = true;
+}
+
+fn parse_time(real_time: &str) -> Option<Time> {
+    let time = parse_custom::<FlitterParser>(real_time).ok()?;
+    Some(Time::new().with_real_time(Some(time)))
+}
+
+/// Attempts to parse an Flitter splits file.
+pub fn parse(source: &str) -> Result<Run> {
+    let splits: Splits<'_> =
+        serde_json::from_str(source).map_err(|source| Error::Json { source })?;
+
+    ensure!(!splits.split_names.is_empty(), SplitNamesEmpty);
+    ensure!(!splits.golds.is_empty(), GoldsEmpty);
+    ensure!(!splits.personal_best.splits.is_empty(), PersonalBestEmpty);
+    ensure!(
+        splits.golds.len() == splits.split_names.len(),
+        GoldCountMismatch
+    );
+    ensure!(
+        splits.personal_best.splits.len() == splits.split_names.len(),
+        PersonalBestCountMismatch
+    );
+    ensure!(
+        splits.personal_best.splits.last().unwrap().is_some(),
+        LastSplitNull
+    );
+
+    let mut run = Run::new();
+
+    run.set_game_name(splits.title);
+    run.set_category_name(splits.category);
+    run.set_attempt_count(splits.attempts);
+
+    let segments = run.segments_mut();
+
+    segments.extend(splits.split_names.into_iter().map(Segment::new));
+
+    for (segment, pb) in segments.iter_mut().zip(splits.personal_best.splits) {
+        catch! {
+            segment.set_personal_best_split_time(parse_time(&pb?.time)?);
+        };
+    }
+
+    for (segment, gold) in segments.iter_mut().zip(splits.golds) {
+        catch! {
+            segment.set_best_segment_time(parse_time(&gold?.duration)?);
+        };
+    }
+
+    Ok(run)
+}
diff --git a/src/run/parser/flitter/mod.rs b/src/run/parser/flitter/mod.rs
deleted file mode 100644
index e2eaf0a9..00000000
--- a/src/run/parser/flitter/mod.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-//! Provides the parser for Flitter splits files.
-
-use crate::{comparison::world_record, platform::prelude::*, Run, Segment, Time, TimeSpan};
-use core::result::Result as StdResult;
-use serde_derive::Deserialize;
-
-mod s_expressions;
-
-pub use self::s_expressions::Error;
-
-/// The Result type for the Flitter Parser.
-pub type Result<T> = StdResult<T, Error>;
-
-#[derive(Deserialize)]
-struct Splits<'a> {
-    title: &'a str,
-    category: &'a str,
-    attempts: u32,
-    #[serde(borrow)]
-    split_names: Vec<&'a str>,
-    golds: Option<Vec<Gold>>,
-    personal_best: Option<Comparison>,
-    world_record: Option<Comparison>,
-}
-
-#[derive(Deserialize)]
-struct Gold {
-    duration: Option<TimeSpan>,
-}
-
-#[derive(Deserialize)]
-struct Comparison {
-    splits: Vec<Split>,
-}
-
-#[derive(Deserialize)]
-struct Split {
-    time: Option<TimeSpan>,
-}
-
-/// Attempts to parse a Flitter splits file.
-pub fn parse(source: &str) -> Result<Run> {
-    let splits: Splits<'_> = self::s_expressions::from_str(source)?;
-
-    let mut run = Run::new();
-
-    run.set_game_name(splits.title);
-    run.set_category_name(splits.category);
-    run.set_attempt_count(splits.attempts);
-
-    if splits.world_record.is_some() {
-        run.add_custom_comparison(world_record::NAME).unwrap();
-    }
-
-    let segments = run.segments_mut();
-
-    segments.extend(splits.split_names.into_iter().map(Segment::new));
-
-    if let Some(pb) = splits.personal_best {
-        for (segment, pb) in segments.iter_mut().zip(pb.splits) {
-            segment.set_personal_best_split_time(Time::new().with_real_time(pb.time));
-        }
-    }
-
-    if let Some(golds) = splits.golds {
-        for (segment, gold) in segments.iter_mut().zip(golds) {
-            segment.set_best_segment_time(Time::new().with_real_time(gold.duration));
-        }
-    }
-
-    if let Some(wr) = splits.world_record {
-        for (segment, wr) in segments.iter_mut().zip(wr.splits) {
-            segment.comparison_mut(world_record::NAME).real_time = wr.time;
-        }
-    }
-
-    Ok(run)
-}
diff --git a/src/run/parser/flitter/s_expressions.rs b/src/run/parser/flitter/s_expressions.rs
deleted file mode 100644
index 8d6be9f3..00000000
--- a/src/run/parser/flitter/s_expressions.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-//! Implements a serde deserializer for S-Expressions.
-//! <http://people.csail.mit.edu/rivest/Sexp.txt>
-
-use crate::platform::prelude::*;
-use core::{fmt::Display, num::ParseIntError};
-use serde::{
-    de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor},
-    Deserialize,
-};
-
-/// The Error types for splits files that couldn't be parsed by the Flitter
-/// Parser.
-#[derive(Debug, snafu::Snafu)]
-pub enum Error {
-    /// Trailing Characters
-    TrailingCharacters,
-    /// Unexpected end of input
-    Eof,
-    /// Expected an opening parenthesis.
-    ExpectedOpeningParenthesis,
-    /// Expected an closing parenthesis.
-    ExpectedClosingParenthesis,
-    /// Expected a string.
-    ExpectedString,
-    /// Failed to parse an integer.
-    ParseInt {
-        /// The underlying error.
-        source: ParseIntError,
-    },
-    /// Encountered invalid UTF-8 sequence.
-    InvalidUtf8,
-    /// Custom error.
-    #[snafu(display("{error}"))]
-    Custom {
-        /// The underlying error.
-        error: String,
-    },
-}
-
-impl From<ParseIntError> for Error {
-    fn from(source: ParseIntError) -> Self {
-        Self::ParseInt { source }
-    }
-}
-
-impl de::Error for Error {
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        Error::Custom {
-            error: msg.to_string(),
-        }
-    }
-}
-
-pub type Result<T> = core::result::Result<T, Error>;
-
-pub struct Deserializer<'source> {
-    source: &'source str,
-}
-
-impl<'source> Deserializer<'source> {
-    pub const fn from_str(source: &'source str) -> Self {
-        Deserializer { source }
-    }
-
-    fn skip_whitespace(&mut self) {
-        self.source = self.source.trim_start();
-    }
-
-    fn starts_with(&self, c: char) -> bool {
-        self.source.starts_with(c)
-    }
-
-    fn strip_char(&mut self, c: char) -> bool {
-        match self.source.strip_prefix(c) {
-            Some(rem) => {
-                self.source = rem;
-                true
-            }
-            None => false,
-        }
-    }
-
-    fn parse_ident(&mut self) -> &'source str {
-        if let Some((pos, _)) = self
-            .source
-            .char_indices()
-            .find(|&(_, c)| c.is_whitespace() || c == ')')
-        {
-            let (before, after) = &self.source.split_at(pos);
-            self.source = after;
-            before
-        } else {
-            self.source
-        }
-    }
-
-    fn parse_string(&mut self) -> Result<&'source str> {
-        if let Some(rem) = self.source.strip_prefix('"') {
-            if let Some((in_str, after)) = rem.split_once('"') {
-                self.source = after;
-                Ok(in_str)
-            } else {
-                Err(Error::Eof)
-            }
-        } else {
-            Ok(self.parse_ident())
-        }
-    }
-
-    fn skip_to_matching_closing(&mut self) -> Result<()> {
-        let mut count = 0;
-        let mut in_string = false;
-        if let Some((pos, _)) = self.source.char_indices().find(|&(_, c)| {
-            if c == '(' {
-                if !in_string {
-                    count += 1;
-                }
-            } else if c == ')' {
-                if !in_string {
-                    if count == 0 {
-                        return true;
-                    } else {
-                        count -= 1;
-                    }
-                }
-            } else if c == '"' {
-                in_string = !in_string;
-            }
-            false
-        }) {
-            self.source = &self.source[pos..];
-            Ok(())
-        } else {
-            self.source = "";
-            Err(Error::Eof)
-        }
-    }
-}
-
-pub fn from_str<'de, T>(source: &'de str) -> Result<T>
-where
-    T: 'de + Deserialize<'de>,
-{
-    let mut deserializer = Deserializer::from_str(source);
-    let t = T::deserialize(&mut deserializer)?;
-    deserializer.skip_whitespace();
-    if deserializer.source.is_empty() {
-        Ok(t)
-    } else {
-        Err(Error::TrailingCharacters)
-    }
-}
-
-impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_i64<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_u32(self.parse_ident().parse()?)
-    }
-    fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.parse_string()?)
-    }
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.parse_string()?)
-    }
-    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_some(self)
-    }
-    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.skip_whitespace();
-        if self.strip_char('(') {
-            let value = visitor.visit_seq(&mut self)?;
-            if self.strip_char(')') {
-                Ok(value)
-            } else {
-                Err(Error::ExpectedClosingParenthesis)
-            }
-        } else {
-            Err(Error::ExpectedOpeningParenthesis)
-        }
-    }
-    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        _visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.skip_whitespace();
-        if self.strip_char('(') {
-            let value = visitor.visit_map(&mut self)?;
-            if self.strip_char(')') {
-                Ok(value)
-            } else {
-                Err(Error::ExpectedClosingParenthesis)
-            }
-        } else {
-            Err(Error::ExpectedOpeningParenthesis)
-        }
-    }
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_map(visitor)
-    }
-    fn deserialize_enum<V>(
-        self,
-        _name: &'static str,
-        _variants: &'static [&'static str],
-        _visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.parse_ident())
-    }
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.skip_to_matching_closing()?;
-        visitor.visit_unit()
-    }
-}
-
-impl<'de> SeqAccess<'de> for &mut Deserializer<'de> {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        self.skip_whitespace();
-        if self.starts_with(')') {
-            Ok(None)
-        } else {
-            seed.deserialize(&mut **self).map(Some)
-        }
-    }
-}
-
-impl<'de> MapAccess<'de> for &mut Deserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-    where
-        K: DeserializeSeed<'de>,
-    {
-        self.skip_whitespace();
-        if self.starts_with(')') {
-            Ok(None)
-        } else if self.strip_char('(') {
-            self.skip_whitespace();
-            seed.deserialize(&mut **self).map(Some)
-        } else {
-            Err(Error::ExpectedOpeningParenthesis)
-        }
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        self.skip_whitespace();
-        let result = seed.deserialize(&mut **self)?;
-        self.skip_whitespace();
-        if self.strip_char(')') {
-            Ok(result)
-        } else {
-            Err(Error::ExpectedClosingParenthesis)
-        }
-    }
-}
diff --git a/src/settings/layout_background.rs b/src/settings/layout_background.rs
index e23918d4..f495ca9f 100644
--- a/src/settings/layout_background.rs
+++ b/src/settings/layout_background.rs
@@ -32,7 +32,7 @@ pub struct BackgroundImage<I> {
     /// to a reasonable value. The resulting value is the sigma (standard
     /// deviation) of the gaussian blur.
     ///
-    /// ```ignore
+    /// ```text
     /// sigma = BLUR_FACTOR * blur * max(width, height)
     /// ```
     pub blur: f32,
diff --git a/src/timing/mod.rs b/src/timing/mod.rs
index ec854313..85baab7c 100644
--- a/src/timing/mod.rs
+++ b/src/timing/mod.rs
@@ -21,3 +21,5 @@ pub use self::{
     timer_phase::TimerPhase,
     timing_method::TimingMethod,
 };
+
+pub(crate) use self::time_span::{parse_custom, CustomParser};
diff --git a/src/timing/time_span.rs b/src/timing/time_span.rs
index 93622253..1ca9043d 100644
--- a/src/timing/time_span.rs
+++ b/src/timing/time_span.rs
@@ -7,7 +7,7 @@ use core::{
     ops::{Add, AddAssign, Neg, Sub, SubAssign},
     str::FromStr,
 };
-use snafu::{ensure, OptionExt, ResultExt};
+use snafu::{OptionExt, ResultExt};
 
 /// A `TimeSpan` represents a certain span of time.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -67,11 +67,13 @@ impl TimeSpan {
 }
 
 /// The Error type for a `TimeSpan` that couldn't be parsed.
-#[derive(Debug, snafu::Snafu)]
+#[derive(Debug, snafu::Snafu, PartialEq, Eq)]
 #[snafu(context(suffix(false)))]
 pub enum ParseError {
-    /// An empty string is not a valid `TimeSpan`.
-    Empty,
+    /// There are too many colons in the string.
+    TooManyColons,
+    /// A piece separate by a colon is too large.
+    PieceOverflow,
     /// The time is too large to be represented.
     Overflow,
     /// The fractional part contains characters that are not digits.
@@ -82,63 +84,115 @@ pub enum ParseError {
         source: ParseIntError,
     },
     /// Couldn't parse the seconds, minutes, or hours.
-    Time {
+    Piece {
         /// The underlying error.
         source: ParseIntError,
     },
 }
 
-impl FromStr for TimeSpan {
-    type Err = ParseError;
+pub(crate) trait CustomParser {
+    const ASCII_ONLY: bool = false;
+    const ALLOW_NEGATIVE: bool = true;
+    const WITH_DAYS: bool = false;
+}
 
-    fn from_str(mut text: &str) -> Result<Self, ParseError> {
-        // It's faster to use `strip_prefix` with char literals if it's an ASCII
-        // char, otherwise prefer using string literals.
-        #[allow(clippy::single_char_pattern)]
-        let negate =
-            if let Some(remainder) = text.strip_prefix('-').or_else(|| text.strip_prefix("−")) {
-                text = remainder;
-                true
-            } else {
-                false
-            };
+struct DefaultParser;
 
-        let (seconds_text, nanos) =
-            if let Some((seconds, mut nanos)) = AsciiChar::DOT.split_once(text) {
-                if nanos.len() > 9 {
-                    nanos = nanos.get(..9).context(FractionDigits)?;
-                }
-                (
-                    seconds,
-                    nanos.parse::<u32>().context(Fraction)? * 10_u32.pow(9 - nanos.len() as u32),
-                )
+impl CustomParser for DefaultParser {}
+
+pub(crate) fn parse_custom<T: CustomParser>(mut text: &str) -> Result<TimeSpan, ParseError> {
+    // It's faster to use `strip_prefix` with char literals if it's an ASCII
+    // char, otherwise prefer using string literals.
+    #[allow(clippy::single_char_pattern)]
+    let negate = if T::ALLOW_NEGATIVE {
+        if let Some(remainder) = text.strip_prefix('-').or_else(|| {
+            if T::ASCII_ONLY {
+                None
             } else {
-                (text, 0u32)
-            };
+                text.strip_prefix("−")
+            }
+        }) {
+            text = remainder;
+            true
+        } else {
+            false
+        }
+    } else {
+        false
+    };
 
-        ensure!(!seconds_text.is_empty(), Empty);
+    let (mut rem, nanos) = if let Some((seconds, mut nanos)) = AsciiChar::DOT.split_once(text) {
+        if nanos.len() > 9 {
+            nanos = nanos.get(..9).context(FractionDigits)?;
+        }
+        (
+            seconds,
+            nanos.parse::<u32>().context(Fraction)? * 10_u32.pow(9 - nanos.len() as u32),
+        )
+    } else {
+        (text, 0u32)
+    };
+
+    let mut seconds = 0u64;
+
+    let mut factor = 1;
+    let max_pieces = const {
+        if T::WITH_DAYS {
+            4
+        } else {
+            3
+        }
+    };
+    for i in 0.. {
+        if i == max_pieces {
+            return Err(ParseError::TooManyColons);
+        }
+        match AsciiChar::COLON.rsplit_once(rem) {
+            Some((new_rem, piece)) => {
+                rem = new_rem;
+                let piece = piece.parse::<u64>().context(Piece)?;
+                let max = if i < 3 { 60 } else { 24 };
+                if piece >= max {
+                    return Err(ParseError::PieceOverflow);
+                }
+                seconds = piece
+                    .checked_mul(factor)
+                    .context(Overflow)?
+                    .checked_add(seconds)
+                    .context(Overflow)?;
+                factor *= max;
+            }
+            None => {
+                let piece = rem.parse::<u64>().context(Piece)?;
+                seconds = piece
+                    .checked_mul(factor)
+                    .context(Overflow)?
+                    .checked_add(seconds)
+                    .context(Overflow)?;
+                break;
+            }
+        }
+    }
 
-        let mut seconds = 0u64;
+    let (mut seconds, mut nanos) = (
+        i64::try_from(seconds).ok().context(Overflow)?,
+        i32::try_from(nanos).ok().context(Overflow)?,
+    );
 
-        for split in AsciiChar::COLON.split_iter(seconds_text) {
-            seconds = seconds
-                .checked_mul(60)
-                .context(Overflow)?
-                .checked_add(split.parse::<u64>().context(Time)?)
-                .context(Overflow)?;
-        }
+    if T::ALLOW_NEGATIVE && negate {
+        seconds = -seconds;
+        nanos = -nanos;
+    }
 
-        let (mut seconds, mut nanos) = (
-            i64::try_from(seconds).ok().context(Overflow)?,
-            i32::try_from(nanos).ok().context(Overflow)?,
-        );
+    Ok(Duration::new(seconds, nanos).into())
+}
 
-        if negate {
-            seconds = -seconds;
-            nanos = -nanos;
-        }
+impl FromStr for TimeSpan {
+    type Err = ParseError;
 
-        Ok(Duration::new(seconds, nanos).into())
+    #[inline]
+    fn from_str(text: &str) -> Result<Self, ParseError> {
+        parse_custom::<DefaultParser>(text)
     }
 }
 
@@ -237,16 +291,44 @@ mod tests {
         TimeSpan::from_str("-100").unwrap();
         TimeSpan::from_str("--30").unwrap_err();
         TimeSpan::from_str("-").unwrap_err();
-        TimeSpan::from_str("").unwrap_err();
         TimeSpan::from_str("-10:-30").unwrap_err();
         TimeSpan::from_str("10:-30").unwrap_err();
         TimeSpan::from_str("10.5:30.5").unwrap_err();
         TimeSpan::from_str("NaN").unwrap_err();
         TimeSpan::from_str("Inf").unwrap_err();
         assert!(matches!(
-            TimeSpan::from_str("1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1"),
-            Err(ParseError::Overflow),
+            TimeSpan::from_str(""),
+            Err(ParseError::Piece {
+                source: ParseIntError { .. }
+            })
         ));
+        assert_eq!(
+            TimeSpan::from_str("60")
+                .unwrap()
+                .to_seconds_and_subsec_nanoseconds(),
+            (60, 0)
+        );
+        assert_eq!(TimeSpan::from_str("0:60"), Err(ParseError::PieceOverflow));
+        assert_eq!(
+            TimeSpan::from_str("60:00")
+                .unwrap()
+                .to_seconds_and_subsec_nanoseconds(),
+            (3600, 0)
+        );
+        assert_eq!(
+            TimeSpan::from_str("0:60:00"),
+            Err(ParseError::PieceOverflow)
+        );
+        assert_eq!(
+            TimeSpan::from_str("24:00:00")
+                .unwrap()
+                .to_seconds_and_subsec_nanoseconds(),
+            (86400, 0)
+        );
+        assert_eq!(
+            TimeSpan::from_str("0:24:00:00"),
+            Err(ParseError::TooManyColons),
+        );
         assert_eq!(
             TimeSpan::from_str("10.123456789")
                 .unwrap()
diff --git a/src/util/ascii_char.rs b/src/util/ascii_char.rs
index 206ded11..0ae469a5 100644
--- a/src/util/ascii_char.rs
+++ b/src/util/ascii_char.rs
@@ -1,5 +1,3 @@
-use core::iter;
-
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct AsciiChar(u8);
@@ -38,28 +36,19 @@ impl AsciiChar {
         memchr::memchr(self.0, text.as_bytes()).is_some()
     }
 
-    pub fn split_once(self, text: &str) -> Option<(&str, &str)> {
-        let pos = memchr::memchr(self.0, text.as_bytes())?;
+    pub fn rsplit_once(self, text: &str) -> Option<(&str, &str)> {
+        let pos = memchr::memrchr(self.0, text.as_bytes())?;
         // SAFETY: memchr guarantees that the position is valid. Also since we
         // are looking for ASCII bytes, splitting at the position is guaranteed
         // to be valid UTF-8.
         unsafe { Some((text.get_unchecked(..pos), text.get_unchecked(pos + 1..))) }
     }
 
-    pub fn split_iter(self, text: &str) -> impl Iterator<Item = &str> {
-        let mut slot = Some(text);
-        iter::from_fn(move || {
-            let rem = slot?;
-            Some(match self.split_once(rem) {
-                Some((before, after)) => {
-                    slot = Some(after);
-                    before
-                }
-                None => {
-                    slot = None;
-                    rem
-                }
-            })
-        })
+    pub fn split_once(self, text: &str) -> Option<(&str, &str)> {
+        let pos = memchr::memchr(self.0, text.as_bytes())?;
+        // SAFETY: memchr guarantees that the position is valid. Also since we
+        // are looking for ASCII bytes, splitting at the position is guaranteed
+        // to be valid UTF-8.
+        unsafe { Some((text.get_unchecked(..pos), text.get_unchecked(pos + 1..))) }
     }
 }
diff --git a/tests/run_files/flitter.json b/tests/run_files/flitter.json
new file mode 100644
index 00000000..df5439c4
--- /dev/null
+++ b/tests/run_files/flitter.json
@@ -0,0 +1,81 @@
+{
+  "title": "Super Monkey Ball 2: Monkeyed Ball",
+  "category": "Story Mode All Levels",
+  "attempts": 3316,
+  "completed": 30,
+  "split_names": [
+    "World 1",
+    "World 2",
+    "World 3",
+    "World 4",
+    "World 5",
+    "World 6",
+    "World 7",
+    "World 8",
+    "World 9",
+    "World 10"
+  ],
+  "golds": [
+    {
+      "duration": "2:11.832"
+    },
+    {
+      "duration": "2:19.000"
+    },
+    null,
+    {
+      "duration": "2:16.000"
+    },
+    {
+      "duration": "2:09.133"
+    },
+    {
+      "duration": "2:24.000"
+    },
+    {
+      "duration": "2:34.258"
+    },
+    {
+      "duration": "2:28.164"
+    },
+    {
+      "duration": "2:29.000"
+    },
+    {
+      "duration": "4:02.718"
+    }
+  ],
+  "personal_best": {
+    "attempt": 3300,
+    "splits": [
+      {
+        "time": "2:13.254"
+      },
+      {
+        "time": "4:38.476"
+      },
+      {
+        "time": "6:40.419"
+      },
+      {
+        "time": "9:01.785"
+      },
+      {
+        "time": "11:10.919"
+      },
+      {
+        "time": "13:48.517"
+      },
+      null,
+      {
+        "time": "18:52.920"
+      },
+      {
+        "time": "21:30.001"
+      },
+      {
+        "time": "25:32.719"
+      }
+    ]
+  }
+}
diff --git a/tests/run_files/mod.rs b/tests/run_files/mod.rs
index 94e8c3fe..8531bac1 100644
--- a/tests/run_files/mod.rs
+++ b/tests/run_files/mod.rs
@@ -1,8 +1,7 @@
 #![allow(dead_code)]
 
 pub const CELESTE: &str = include_str!("Celeste - Any% (1.2.1.5).lss");
-pub const FLITTER_SMALL: &str = include_str!("flitter-small.scm");
-pub const FLITTER: &str = include_str!("flitter.scm");
+pub const FLITTER: &str = include_str!("flitter.json");
 pub const GENERIC_SPLITS_IO: &str = include_str!("generic_splits_io.json");
 pub const LIVESPLIT_1_0: &str = include_str!("livesplit1.0.lss");
 pub const LIVESPLIT_1_4: &str = include_str!("livesplit1.4.lss");
diff --git a/tests/split_parsing.rs b/tests/split_parsing.rs
index 712a66ba..8ae0144d 100644
--- a/tests/split_parsing.rs
+++ b/tests/split_parsing.rs
@@ -145,11 +145,6 @@ mod parse {
         flitter::parse(run_files::FLITTER).unwrap();
     }
 
-    #[test]
-    fn flitter_small() {
-        flitter::parse(run_files::FLITTER_SMALL).unwrap();
-    }
-
     #[test]
     fn source_live_timer() {
         source_live_timer::parse(run_files::SOURCE_LIVE_TIMER).unwrap();
@@ -220,8 +215,5 @@ mod parse {
     fn flitter_prefers_parsing_as_itself() {
         let run = composite::parse(run_files::FLITTER.as_bytes(), None).unwrap();
         assert_eq!(run.kind, TimerKind::Flitter);
-
-        let run = composite::parse(run_files::FLITTER_SMALL.as_bytes(), None).unwrap();
-        assert_eq!(run.kind, TimerKind::Flitter);
     }
 }