yaahc/eyre - Change YNTEYSW7NVBWQLJU45XRK7AWQR5NWFOB4UUVVQ62ERZOO2QJJGAAC

Move error formatting to fmt.rs

Created by David Tolnay on November 15, 2019

YNTEYSW7NVBWQLJU45XRK7AWQR5NWFOB4UUVVQ62ERZOO2QJJGAAC

Dependencies

In channels

main

Change contents

Replacement in src/error.rs at line 655 [9.3238]

∅:D[7.113] → [8.1628:1693]

B:BD[9.9978] → [8.1628:1693]

    fn error(&self) -> &(dyn StdError + Send + Sync + 'static) {

[7.113]

[3.446]

    pub(crate) fn error(&self) -> &(dyn StdError + Send + Sync + 'static) {

Replacement in src/error.rs at line 659 [9.3238]

B:BD[9.10202] → [8.1694:1771]

    fn error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {

[9.10202]

[3.499]

    pub(crate) fn error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {

Replacement in src/error.rs at line 664 [9.3238]

B:BD[10.544] → [10.544:584]

    fn backtrace(&self) -> &Backtrace {

[10.544]

[10.584]

    pub(crate) fn backtrace(&self) -> &Backtrace {

Replacement in src/error.rs at line 674 [9.3238]
B:BD[10.910] → [10.910:941]
```
    fn chain(&self) -> Chain {
```
[10.910]
[10.941]
```
    pub(crate) fn chain(&self) -> Chain {
```

Deletion in src/error.rs at line 679 [9.3238]

B:BD[11.239] → [11.239:240]

B:BD[11.240] → [6.192:299]

∅:D[6.299] → [10.1115:1234]

B:BD[10.1115] → [10.1115:1234]

B:BD[10.1234] → [6.300:348]

∅:D[6.348] → [10.1280:1373]

B:BD[10.1280] → [10.1280:1373]

B:BD[10.1373] → [6.349:386]

∅:D[6.386] → [10.1412:1450]

B:BD[10.1412] → [10.1412:1450]

B:BD[10.1450] → [6.387:441]

∅:D[6.441] → [10.1504:1528]

B:BD[10.1504] → [10.1504:1528]

B:BD[10.1528] → [6.442:464]

∅:D[6.464] → [10.1528:1529]

B:BD[10.1528] → [10.1528:1529]

B:BD[10.1529] → [6.465:863]

∅:D[6.863] → [10.1529:1747]

B:BD[10.1529] → [10.1529:1747]

B:BD[10.1747] → [4.0:272]

∅:D[4.272] → [12.0:51]

B:BD[10.1747] → [12.0:51]

∅:D[12.51] → [10.1800:1922]

B:BD[10.1800] → [10.1800:1922]

B:BD[10.1922] → [5.0:116]

∅:D[5.116] → [10.2044:2156]

B:BD[10.2044] → [10.2044:2156]


    fn print_chain(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.error())?;
        let mut chain = self.chain().skip(1).enumerate().peekable();
        if let Some((n, error)) = chain.next() {
            write!(f, "\n\nCaused by:\n    ")?;
            if chain.peek().is_some() {
                write!(f, "{}: ", n)?;
            }
            write!(f, "{}", error)?;
            for (n, error) in chain {
                write!(f, "\n    {}: {}", n, error)?;
            }
        }
        Ok(())
    }
    fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if f.alternate() {
            self.print_chain(f)
        } else {
            write!(f, "{}", self.error())
        }
    }
    fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if f.alternate() {
            return Debug::fmt(self.error(), f);
        }
        self.print_chain(f)?;
        writeln!(f)?;
        #[cfg(backtrace)]
        {
            use std::backtrace::BacktraceStatus;
            let backtrace = self.backtrace();
            match backtrace.status() {
                BacktraceStatus::Captured => {
                    let mut backtrace = backtrace.to_string();
                    if backtrace.starts_with("stack backtrace:") {
                        // Capitalize to match "Caused by:"
                        backtrace.replace_range(0..1, "S");
                    }
                    write!(f, "\n{}", backtrace)?;
                }
                BacktraceStatus::Disabled => {
                    writeln!(
                        f,
                        "\nStack backtrace:\n    Run with RUST_LIB_BACKTRACE=1 env variable to display a backtrace"
                    )?;
                }
                _ => {}
            }
        }
        Ok(())
    }

File addition: fmt.rs (----------)

[9.6]

use crate::error::ErrorImpl;
use std::fmt::{self, Debug};
impl ErrorImpl<()> {
    fn print_chain(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.error())?;
        let mut chain = self.chain().skip(1).enumerate().peekable();
        if let Some((n, error)) = chain.next() {
            write!(f, "\n\nCaused by:\n    ")?;
            if chain.peek().is_some() {
                write!(f, "{}: ", n)?;
            }
            write!(f, "{}", error)?;
            for (n, error) in chain {
                write!(f, "\n    {}: {}", n, error)?;
            }
        }
        Ok(())
    }
    pub(crate) fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if f.alternate() {
            self.print_chain(f)
        } else {
            write!(f, "{}", self.error())
        }
    }
    pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if f.alternate() {
            return Debug::fmt(self.error(), f);
        }
        self.print_chain(f)?;
        writeln!(f)?;
        #[cfg(backtrace)]
        {
            use std::backtrace::BacktraceStatus;
            let backtrace = self.backtrace();
            match backtrace.status() {
                BacktraceStatus::Captured => {
                    let mut backtrace = backtrace.to_string();
                    if backtrace.starts_with("stack backtrace:") {
                        // Capitalize to match "Caused by:"
                        backtrace.replace_range(0..1, "S");
                    }
                    write!(f, "\n{}", backtrace)?;
                }
                BacktraceStatus::Disabled => {
                    writeln!(
                        f,
                        "\nStack backtrace:\n    Run with RUST_LIB_BACKTRACE=1 env variable to display a backtrace"
                    )?;
                }
                _ => {}
            }
        }
        Ok(())
    }
}

Insertion in src/lib.rs at line 174 [9.11888]
[13.22]
[2.903]
```
mod fmt;
```