refactor: Improve error messages

sachy-config/src/lib.rs

···
 use core::{error::Error, fmt::Debug, str::FromStr};
 use std::io::Write;
 
-use miette::{Context, IntoDiagnostic, Result, bail, miette};
+use miette::{Context, IntoDiagnostic, LabeledSpan, Result, bail, miette};
 use toml_edit::Value;
 
 fn validate_kind_to_string<T: Debug + FromStr + Send + Sync>(
···
     value
         .as_str()
         .map_or_else(
-            || Err(miette!("{} is not a value", value)),
+            || Err(miette!("{} is not a value @ {:?}", value, value.span())),
             |value_str| {
                 value_str.parse().into_diagnostic().wrap_err_with(|| {
-                    format!("Parsing failure of constant \"{}\" as {}", name, kind)
+                    miette!(
+                        labels = vec![LabeledSpan::at(value.span().unwrap(), "here")],
+                        "Parsing failure of constant \"{}\" as {}",
+                        name,
+                        kind,
+                    )
                 })
             },
         )
···
 }
 
 pub fn parse_config(config: &str) -> Result<String> {
-    let config_doc = config.parse::<toml_edit::DocumentMut>().into_diagnostic()?;
+    let config_doc = config
+        .parse::<toml_edit::Document<String>>()
+        .into_diagnostic()?;
     let mut output = String::new();
 
     config_doc
···
         .try_for_each(|(name, item)| -> miette::Result<()> {
             let value = item.as_str().ok_or_else(|| {
                 miette!(
-                    "{} is not a string value. Actual type: {}",
+                    "{} is not a string value. Actual type: {} @ {:?}",
                     name,
                     item.type_name(),
+                    item.span()
                 )
             })?;
             let static_output = format!("pub static {}: &str = \"{}\";\n", name, value);
···
             let kind = &constant_value["type"];
             let kind = kind.as_str().ok_or_else(|| {
                 miette!(
-                    "{} is not a string value. Actual type: {}",
+                    "{} is not a string value. Actual type: {} @ {:?}",
                     name,
                     kind.type_name(),
+                    constant_value.span()
                 )
             })?;
             let value = &constant_value["value"];
             let value = value.as_value().ok_or_else(|| {
                 miette!(
-                    "{} is not a value. Actual type: {}",
+                    labels = vec![LabeledSpan::at(value.span().unwrap(), "here")],
+                    "{} is not a value. Actual type: {} @ {:?}",
                     name,
                     value.type_name(),
+                    value.span(),
                 )
+                .with_source_code(config_doc.to_string())
             })?;
 
             let line = match kind {