yaahc/eyre - Change N7U2FHPRHGARPZ6M7LYBDJ52NMYE23VD5YALZ7CC76W3V5OLBP7QC

move fmting to trait and add github actions support

Created by Jane Lusby on February 28, 2020

N7U2FHPRHGARPZ6M7LYBDJ52NMYE23VD5YALZ7CC76W3V5OLBP7QC

Dependencies

In channels

main

Change contents

File deletion: .travis.yml

BF:BFD[1.0] → [5.0:13]

BF:BFD[5.13] → [5.14:14]

B:BD[5.14] → [5.15:30]

B:BD[5.30] → [6.0:40]

B:BD[6.40] → [7.0:61]

∅:D[7.61] → [6.41:61]

B:BD[5.63] → [6.41:61]

B:BD[6.61] → [8.0:19]

B:BD[8.19] → [2.0:93]

∅:D[2.93] → [9.0:153]

∅:D[7.142] → [9.0:153]

B:BD[6.106] → [9.0:153]

language: rust
rust:
  - nightly
  - beta
  - stable
script:
  - cargo test
  - cargo check --no-default-features
matrix:
  include:
    - rust: 1.34.0
      script: cargo check
    - rust: 1.36.0
      script: cargo check --no-default-features
    - rust: nightly
      name: Clippy
      script:
        - rustup component add clippy || travis_terminate 0
        - cargo clippy -- -Dclippy::all

File addition: .github (d--x------)
[1.0]
File addition: workflows (d--x------)
[0.10]

File addition: ci.yml (----------)

[0.23]

on: [push, pull_request]
name: Continuous integration
jobs:
  check:
    name: Check
    runs-on: ubuntu-latest
    strategy:
      matrix:
        rust:
          - stable
          - 1.31.0
    steps:
      - uses: actions/checkout@v1
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: ${{ matrix.rust }}
          override: true
      - uses: actions-rs/cargo@v1
        with:
          command: check
  test:
    name: Test Suite
    runs-on: ubuntu-latest
    strategy:
      matrix:
        rust:
          - stable
          - nightly
          - 1.31.0
    steps:
      - uses: actions/checkout@v1
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: ${{ matrix.rust }}
          override: true
      - uses: actions-rs/cargo@v1
        with:
          command: test
      - uses: actions-rs/cargo@v1
        with:
          command: test
          args: --no-default-features
  fmt:
    name: Rustfmt
    runs-on: ubuntu-latest
    strategy:
      matrix:
        rust:
          - stable
          - 1.31.0
    steps:
      - uses: actions/checkout@v1
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: ${{ matrix.rust }}
          override: true
      - run: rustup component add rustfmt
      - uses: actions-rs/cargo@v1
        with:
          command: fmt
          args: --all -- --check
  clippy:
    name: Clippy
    runs-on: ubuntu-latest
    strategy:
      matrix:
        rust:
          - stable
          - 1.31.0
    steps:
      - uses: actions/checkout@v1
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: ${{ matrix.rust }}
          override: true
      - run: rustup component add clippy
      - uses: actions-rs/cargo@v1
        with:
          command: clippy
          args: -- -D warnings

Replacement in README.md at line 8 [12.12]

B:BD[10.1] → [11.450:528]

∅:D[11.528] → [10.81:137]

B:BD[10.81] → [10.81:137]

This library provides [`eyre::Error`][Error], a trait object based error type
for easy idiomatic error handling in Rust applications.

[10.1]

[12.381]

This library provides [`eyre::ErrReport`][ErrReport], a trait object based
error handling type for easy idiomatic error handling and reporting in Rust
applications.

Replacement in README.md at line 12 [12.12]

B:BD[12.382] → [11.529:586]

[Error]: https://docs.rs/eyre/1.0/eyre/struct.Error.html

[12.382]

[10.209]

[ErrReport]: https://docs.rs/eyre/1.0/eyre/struct.ErrReport.html

Replacement in README.md at line 25 [12.12]

B:BD[13.13] → [11.601:675]

- Use `Result<T, eyre::Error>`, or equivalently `eyre::Result<T>`, as the

[13.13]

[13.91]

- Use `Result<T, eyre::ErrReport>`, or equivalently `eyre::Result<T>`, as the

Replacement in README.md at line 103 [12.12]

B:BD[11.804] → [11.804:867]

  supports string interpolation and produces an `eyre::Error`.

[11.804]

[13.1763]

  supports string interpolation and produces an `eyre::ErrReport`.

Replacement in README.md at line 124 [12.12]

B:BD[14.457] → [4.180:258]

require an explicit `.map_err(Error::msg)` when working with a non-Eyre error

[14.457]

[4.258]

require an explicit `.map_err(ErrReport::msg)` when working with a non-Eyre error

Replacement in README.md at line 131 [12.12]

B:BD[13.1770] → [11.978:1051]

The `eyre::Error` type works something like `failure::Error`, but unlike

[13.1770]

[15.102]

The `eyre::ErrReport` type works something like `failure::Error`, but unlike

Replacement in src/error.rs at line 677 [17.3238]
B:BD[16.9579] → [16.9579:9595]
```
    context: C,
```
[16.9579]
[18.2132]
```
    pub(crate) context: C,
```
Deletion in src/fmt.rs at line 1 [19.270]
B:BD[19.270] → [20.1445:1470]
```
use crate::chain::Chain;
```
Replacement in src/fmt.rs at line 2 [19.270]
B:BD[19.300] → [21.0:37]
```
use core::fmt::{self, Debug, Write};
```
[19.300]
[16.10753]
```
use core::fmt::{self, Write};
```

Replacement in src/fmt.rs at line 10 [19.270]

∅:D[22.74] → [19.418:459]

B:BD[19.418] → [19.418:459]

B:BD[19.459] → [22.75:193]

∅:D[22.193] → [19.704:718]

B:BD[19.704] → [19.704:718]

B:BD[19.861] → [19.861:887]

        write!(f, "{}", self.error())?;
        if f.alternate() {
            for cause in self.chain().skip(1) {
                write!(f, ": {}", cause)?;
            }
        }
        Ok(())

[22.74]

[19.887]

        self.context.display(self.error(), f)

Replacement in src/fmt.rs at line 14 [19.270]

B:BD[19.1175] → [23.19:54]

∅:D[23.54] → [19.1175:1202]

B:BD[19.1175] → [19.1175:1202]

B:BD[19.1202] → [23.55:96]

∅:D[23.96] → [19.1250:1261]

B:BD[19.1250] → [19.1250:1261]

B:BD[19.1261] → [24.0:33]

∅:D[24.33] → [22.236:237]

∅:D[23.132] → [22.236:237]

B:BD[22.236] → [22.236:237]

B:BD[22.237] → [23.133:179]

B:BD[23.179] → [24.34:76]

∅:D[24.76] → [23.221:336]

B:BD[23.221] → [23.221:336]

B:BD[23.336] → [21.38:68]

B:BD[21.68] → [25.0:76]

B:BD[25.76] → [3.0:67]

∅:D[3.67] → [25.140:243]

B:BD[25.140] → [25.140:243]

∅:D[24.157] → [22.625:649]

∅:D[25.243] → [22.625:649]

∅:D[21.340] → [22.625:649]

∅:D[23.506] → [22.625:649]

B:BD[22.625] → [22.625:649]

∅:D[22.649] → [19.1313:1446]

B:BD[19.1313] → [19.1313:1446]

B:BD[19.1446] → [26.0:302]

∅:D[26.302] → [19.2117:2135]

B:BD[19.2117] → [19.2117:2135]

B:BD[19.2135] → [24.158:271]

B:BD[24.271] → [21.341:381]

        let error = self.error();
        if f.alternate() {
            return Debug::fmt(error, f);
        }
        write!(f, "{}", error)?;
        if let Some(cause) = error.source() {
            write!(f, "\n\nCaused by:")?;
            let multiple = cause.source().is_some();
            for (n, error) in Chain::new(cause).enumerate() {
                writeln!(f)?;
                let mut indented = Indented {
                    inner: f,
                    number: if multiple { Some(n) } else { None },
                    started: false,
                };
                write!(indented, "{}", error)?;
            }
        }
        #[cfg(backtrace)]
        {
            use std::backtrace::BacktraceStatus;
            let backtrace = self.backtrace();
            if let BacktraceStatus::Captured = backtrace.status() {
                let mut backtrace = backtrace.to_string();
                if backtrace.starts_with("stack backtrace:") {
                    // Capitalize to match "Caused by:"
                    backtrace.replace_range(0..1, "S");
                }
                backtrace.truncate(backtrace.trim_end().len());
                write!(f, "\n\n{}", backtrace)?;
            }
        }
        Ok(())

[19.1175]

[21.381]

        self.context.debug(self.error(), f)

Replacement in src/fmt.rs at line 18 [19.270]

B:BD[21.390] → [21.390:437]

B:BD[21.437] → [3.68:95]

∅:D[3.95] → [21.461:480]

B:BD[21.461] → [21.461:480]

struct Indented<'a, D> {
    inner: &'a mut D,
    number: Option<usize>,
    started: bool,

[21.390]

[21.480]

pub(crate) struct Indented<'a, D> {
    pub(crate) inner: &'a mut D,
    pub(crate) number: Option<usize>,
    pub(crate) started: bool,

Insertion in src/lib.rs at line 336 [17.11888]

[16.11618]


    fn display(&self, error: &(dyn std::error::Error + 'static), f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result;
    fn debug(&self, error: &(dyn std::error::Error + 'static), f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result;

Replacement in src/lib.rs at line 343 [17.11888]
B:BD[16.11649] → [16.11649:11683]
```
    backtrace: Option<Backtrace>,
```
[16.11649]
[16.11683]
```
    pub backtrace: Option<Backtrace>,
```

Insertion in src/lib.rs at line 359 [17.11888]

[16.12107]

        }
    }
    fn display(&self, error: &(dyn std::error::Error + 'static), f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", error)?;
        if f.alternate() {
            for cause in Chain::new(error).skip(1) {
                write!(f, ": {}", cause)?;
            }
        }
        Ok(())
    }
    fn debug(&self, error: &(dyn std::error::Error + 'static), f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        use core::fmt::Write as _;
        if f.alternate() {
            return core::fmt::Debug::fmt(error, f);
        }
        write!(f, "{}", error)?;
        if let Some(cause) = error.source() {
            write!(f, "\n\nCaused by:")?;
            let multiple = cause.source().is_some();
            for (n, error) in Chain::new(cause).enumerate() {
                writeln!(f)?;
                let mut indented = fmt::Indented {
                    inner: f,
                    number: if multiple { Some(n) } else { None },
                    started: false,
                };
                write!(indented, "{}", error)?;
            }
        }
        #[cfg(backtrace)]
        {
            use std::backtrace::BacktraceStatus;
            let backtrace = self.backtrace.as_ref().or_else(|| error.backtrace()).expect("backtrace capture failed");
            if let BacktraceStatus::Captured = backtrace.status() {
                let mut backtrace = backtrace.to_string();
                if backtrace.starts_with("stack backtrace:") {
                    // Capitalize to match "Caused by:"
                    backtrace.replace_range(0..1, "S");
                }
                backtrace.truncate(backtrace.trim_end().len());
                write!(f, "\n\n{}", backtrace)?;
            }

Insertion in src/lib.rs at line 412 [17.11888]
[16.12117]
[16.12117]
```
        Ok(())
```