Update toml to 0.8.0

Cargo.toml

@@ -127,7 +127,7 @@ divan = "0.1.14"
 glob = "0.3.1"
 serde = { version = "1.0.199", features = ["derive"] }
 snapbox = { version = "0.6.0", features = ["diff", "term-svg", "cmd", "examples"] }
-toml = "0.5.11"
+toml = "0.8.0"
 tryfn = "0.2.1"
 
 [[bench]]

tests/fixtures/deserialize.rs

@@ -1,36 +1,30 @@
-use serde::{Deserialize, Deserializer, Serialize};
+use serde::Deserialize;
 use std::ops::Range;
 
 use annotate_snippets::renderer::DEFAULT_TERM_WIDTH;
 use annotate_snippets::{Annotation, Level, Message, Renderer, Snippet};
 
 #[derive(Deserialize)]
-pub(crate) struct Fixture<'a> {
+pub(crate) struct Fixture {
     #[serde(default)]
     pub(crate) renderer: RendererDef,
-    #[serde(borrow)]
-    pub(crate) message: MessageDef<'a>,
+    pub(crate) message: MessageDef,
 }
 
 #[derive(Deserialize)]
-pub struct MessageDef<'a> {
+pub struct MessageDef {
     #[serde(with = "LevelDef")]
     pub level: Level,
-    #[serde(borrow)]
-    pub title: &'a str,
+    pub title: String,
     #[serde(default)]
-    #[serde(borrow)]
-    pub id: Option<&'a str>,
+    pub id: Option<String>,
     #[serde(default)]
-    #[serde(borrow)]
-    pub footer: Vec<MessageDef<'a>>,
-    #[serde(deserialize_with = "deserialize_snippets")]
-    #[serde(borrow)]
-    pub snippets: Vec<Snippet<'a>>,
+    pub footer: Vec<MessageDef>,
+    pub snippets: Vec<SnippetDef>,
 }
 
-impl<'a> From<MessageDef<'a>> for Message<'a> {
-    fn from(val: MessageDef<'a>) -> Self {
+impl<'a> From<&'a MessageDef> for Message<'a> {
+    fn from(val: &'a MessageDef) -> Self {
         let MessageDef {
             level,
             title,
@@ -42,100 +36,61 @@ impl<'a> From<MessageDef<'a>> for Message<'a> {
         if let Some(id) = id {
             message = message.id(id);
         }
-        message = message.snippets(snippets);
-        message = message.footers(footer.into_iter().map(Into::into));
+        message = message.snippets(snippets.iter().map(Snippet::from));
+        message = message.footers(footer.iter().map(Into::into));
         message
     }
 }
 
-fn deserialize_snippets<'de, D>(deserializer: D) -> Result<Vec<Snippet<'de>>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    #[derive(Deserialize)]
-    struct Wrapper<'a>(
-        #[serde(with = "SnippetDef")]
-        #[serde(borrow)]
-        SnippetDef<'a>,
-    );
-
-    let v = Vec::deserialize(deserializer)?;
-    Ok(v.into_iter().map(|Wrapper(a)| a.into()).collect())
-}
-
 #[derive(Deserialize)]
-pub struct SnippetDef<'a> {
-    #[serde(borrow)]
-    pub source: &'a str,
+pub struct SnippetDef {
+    pub source: String,
     pub line_start: usize,
-    #[serde(borrow)]
-    pub origin: Option<&'a str>,
-    #[serde(deserialize_with = "deserialize_annotations")]
-    #[serde(borrow)]
-    pub annotations: Vec<Annotation<'a>>,
+    pub origin: Option<String>,
+    pub annotations: Vec<AnnotationDef>,
     #[serde(default)]
     pub fold: bool,
 }
 
-impl<'a> From<SnippetDef<'a>> for Snippet<'a> {
-    fn from(val: SnippetDef<'a>) -> Self {
+impl<'a> From<&'a SnippetDef> for Snippet<'a> {
+    fn from(val: &'a SnippetDef) -> Self {
         let SnippetDef {
             source,
             line_start,
             origin,
             annotations,
             fold,
         } = val;
-        let mut snippet = Snippet::source(source).line_start(line_start).fold(fold);
+        let mut snippet = Snippet::source(source).line_start(*line_start).fold(*fold);
         if let Some(origin) = origin {
             snippet = snippet.origin(origin);
         }
-        snippet = snippet.annotations(annotations);
+        snippet = snippet.annotations(annotations.iter().map(Into::into));
         snippet
     }
 }
 
-fn deserialize_annotations<'de, D>(deserializer: D) -> Result<Vec<Annotation<'de>>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    #[derive(Deserialize)]
-    struct Wrapper<'a>(#[serde(borrow)] AnnotationDef<'a>);
-
-    let v = Vec::deserialize(deserializer)?;
-    Ok(v.into_iter().map(|Wrapper(a)| a.into()).collect())
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct AnnotationDef<'a> {
+#[derive(Deserialize)]
+pub struct AnnotationDef {
     pub range: Range<usize>,
-    #[serde(borrow)]
-    pub label: &'a str,
+    pub label: String,
     #[serde(with = "LevelDef")]
     pub level: Level,
 }
 
-impl<'a> From<AnnotationDef<'a>> for Annotation<'a> {
-    fn from(val: AnnotationDef<'a>) -> Self {
+impl<'a> From<&'a AnnotationDef> for Annotation<'a> {
+    fn from(val: &'a AnnotationDef) -> Self {
         let AnnotationDef {
             range,
             label,
             level,
         } = val;
-        level.span(range).label(label)
+        level.span(range.start..range.end).label(label)
     }
 }
 
-#[derive(Serialize, Deserialize)]
-pub(crate) struct LabelDef<'a> {
-    #[serde(with = "LevelDef")]
-    pub(crate) level: Level,
-    #[serde(borrow)]
-    pub(crate) label: &'a str,
-}
-
 #[allow(dead_code)]
-#[derive(Serialize, Deserialize)]
+#[derive(Deserialize)]
 #[serde(remote = "Level")]
 enum LevelDef {
     Error,

tests/fixtures/main.rs

@@ -33,8 +33,10 @@ fn setup(input_path: std::path::PathBuf) -> tryfn::Case {
 
 fn test(input_path: &std::path::Path) -> Result<Data, Box<dyn Error>> {
     let src = std::fs::read_to_string(input_path)?;
-    let (renderer, message): (Renderer, Message<'_>) =
-        toml::from_str(&src).map(|a: Fixture<'_>| (a.renderer.into(), a.message.into()))?;
+    let fixture: Fixture = toml::from_str(&src)?;
+    let renderer: Renderer = fixture.renderer.into();
+    let message: Message<'_> = (&fixture.message).into();
+
     let actual = renderer.render(message).to_string();
     Ok(Data::from(actual).coerce_to(DataFormat::TermSvg))
 }