Adadpt exn to most pressing needs of gitoxide

- Top-level `Error`
- dissolve `Exn` back to `Box<E>`
- Use `dyn Error + Send + Sync + 'static'`

Author: Byron

Cargo.lock

@@ -9,7 +9,7 @@ use crate::{
     time::format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
     Error, OffsetInSeconds, SecondsSinceUnixEpoch, Time,
 };
-use gix_error::{Result, ResultExt};
+use gix_error::{Exn, ResultExt};
 
 /// Parse `input` as any time that Git can parse when inputting a date.
 ///
@@ -72,7 +72,7 @@ use gix_error::{Result, ResultExt};
 /// If `now` is October 27, 2023 at 10:00:00 UTC:
 ///     *   `2 minutes ago` (October 27, 2023 at 09:58:00 UTC)
 ///     *   `3 hours ago` (October 27, 2023 at 07:00:00 UTC)
-pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
+pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Exn<Error>> {
     Ok(if let Ok(val) = Date::strptime(SHORT.0, input) {
         let val = val
             .to_zoned(TimeZone::UTC)

gix-date/src/parse/function.rs

@@ -1,10 +1,10 @@
 use std::{str::FromStr, time::SystemTime};
 
 use crate::Error;
-use gix_error::{ensure, ParseError, Result, ResultExt};
+use gix_error::{ensure, Exn, ParseError, ResultExt};
 use jiff::{tz::TimeZone, Span, Timestamp, Zoned};
 
-fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
+fn parse_inner(input: &str) -> Option<Result<Span, Exn<Error>>> {
     let mut split = input.split_whitespace();
     let units = i64::from_str(split.next()?).ok()?;
     let period = split.next()?;
@@ -14,8 +14,8 @@ fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
     span(period, units)
 }
 
-pub fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Error>> {
-    parse_inner(input).map(|result| -> Result<Zoned, Error> {
+pub fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Exn<Error>>> {
+    parse_inner(input).map(|result| -> Result<Zoned, Exn<Error>> {
         let span = result?;
         // This was an error case in a previous version of this code, where
         // it would fail when converting from a negative signed integer
@@ -36,7 +36,7 @@ pub fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Error
     })
 }
 
-fn span(period: &str, units: i64) -> Option<Result<Span, Error>> {
+fn span(period: &str, units: i64) -> Option<Result<Span, Exn<Error>>> {
     let period = period.strip_suffix('s').unwrap_or(period);
     let result = match period {
         "second" => Span::new().try_seconds(units),

gix-date/src/parse/relative.rs

@@ -1,6 +1,7 @@
 use std::time::SystemTime;
 
 use gix_date::Time;
+use gix_error::Exn;
 
 #[test]
 fn time_without_offset_defaults_to_utc() {
@@ -63,7 +64,7 @@ fn git_rfc2822() {
 }
 
 #[test]
-fn raw() -> gix_error::Result<(), gix_date::Error> {
+fn raw() -> Result<(), Exn<gix_date::Error>> {
     assert_eq!(
         gix_date::parse("1660874655 +0800", None)?,
         Time {

gix-date/tests/time/parse/mod.rs

@@ -11,10 +11,9 @@ edition = "2021"
 include = ["src/**/*", "LICENSE-*"]
 rust-version = "1.82"
 
-[lib]
-doctest = false
-
 [dependencies]
-bstr = { version = "1.12.0", default-features = false }
-exn = { version = "0.2.1", default-features = false }
+bstr = { version = "1.12.0", default-features = false, features = ["std"] }
+
+[dev-dependencies]
+insta = "1.46.0"
 

gix-error/Cargo.toml

@@ -0,0 +1,60 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt;
+use std::fmt::Formatter;
+
+use crate::exn::Exn;
+use crate::exn::Frame;
+
+impl<E: std::error::Error + Send + Sync + 'static> fmt::Debug for Exn<E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write_exn(f, self.as_frame(), 0, "")
+    }
+}
+
+impl fmt::Debug for Frame {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write_exn(f, self, 0, "")
+    }
+}
+
+fn write_exn(f: &mut Formatter<'_>, frame: &Frame, level: usize, prefix: &str) -> fmt::Result {
+    write!(f, "{}", frame.as_error())?;
+    write_location(f, frame)?;
+
+    let children = frame.children();
+    let children_len = children.len();
+
+    for (i, child) in children.iter().enumerate() {
+        write!(f, "\n{prefix}|")?;
+        write!(f, "\n{prefix}|-> ")?;
+
+        let child_child_len = child.children().len();
+        if level == 0 && children_len == 1 && child_child_len == 1 {
+            write_exn(f, child, 0, prefix)?;
+        } else if i < children_len - 1 {
+            write_exn(f, child, level + 1, &format!("{prefix}|   "))?;
+        } else {
+            write_exn(f, child, level + 1, &format!("{prefix}    "))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn write_location(f: &mut Formatter<'_>, exn: &Frame) -> fmt::Result {
+    let location = exn.location();
+    write!(f, ", at {}:{}:{}", location.file(), location.line(), location.column())
+}

gix-error/src/exn/Cargo.toml

@@ -14,10 +14,9 @@
 
 use std::fmt;
 
-use crate::Error;
-use crate::Exn;
+use crate::exn::Exn;
 
-impl<E: Error> fmt::Display for Exn<E> {
+impl<E: std::error::Error + Send + Sync + 'static> fmt::Display for Exn<E> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.as_error())
     }

gix-error/src/exn/debug.rs

@@ -0,0 +1,114 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::exn::Exn;
+
+/// A trait bound of the supported error type of [`Exn`].
+pub trait ErrorExt: std::error::Error + Send + Sync + 'static {
+    /// Raise this error as a new exception.
+    #[track_caller]
+    fn raise(self) -> Exn<Self>
+    where
+        Self: Sized,
+    {
+        Exn::new(self)
+    }
+}
+
+impl<T> ErrorExt for T where T: std::error::Error + Send + Sync + 'static {}
+
+/// An extension trait for [`Option`] to provide raising new exceptions on `None`.
+pub trait OptionExt {
+    /// The `Some` type.
+    type Some;
+
+    /// Construct a new [`Exn`] on the `None` variant.
+    fn ok_or_raise<A, F>(self, err: F) -> Result<Self::Some, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A;
+}
+
+impl<T> OptionExt for Option<T> {
+    type Some = T;
+
+    #[track_caller]
+    fn ok_or_raise<A, F>(self, err: F) -> Result<T, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Some(v) => Ok(v),
+            None => Err(Exn::new(err())),
+        }
+    }
+}
+
+/// An extension trait for [`Result`] to provide context information on [`Exn`]s.
+pub trait ResultExt {
+    /// The `Ok` type.
+    type Success;
+
+    /// The `Err` type that would be wrapped in an [`Exn`].
+    type Error: std::error::Error + Send + Sync + 'static;
+
+    /// Raise a new exception on the [`Exn`] inside the [`Result`].
+    ///
+    /// Apply [`Exn::raise`] on the `Err` variant, refer to it for more information.
+    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A;
+}
+
+impl<T, E> ResultExt for std::result::Result<T, E>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    type Success = T;
+    type Error = E;
+
+    #[track_caller]
+    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Ok(v) => Ok(v),
+            Err(e) => Err(Exn::new(e).raise(err())),
+        }
+    }
+}
+
+impl<T, E> ResultExt for std::result::Result<T, Exn<E>>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    type Success = T;
+    type Error = E;
+
+    #[track_caller]
+    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Ok(v) => Ok(v),
+            Err(e) => Err(e.raise(err())),
+        }
+    }
+}