yaahc/eyre - Change GOPJFSDQLXOY7EGBNR26HON32UIMSC3IAWZZL57A277CMX2D4OOAC

Rename context apis

Created by Jane Lusby on February 27, 2020

GOPJFSDQLXOY7EGBNR26HON32UIMSC3IAWZZL57A277CMX2D4OOAC

Dependencies

In channels

main

Change contents

Replacement in README.md at line 1 [5.12]
B:BD[5.12] → [5.13:42]
```
Anyhow&ensp;¯\\\_(ツ)\_/¯
```
[5.12]
[5.42]
```
Eyre&ensp;¯\\\_(ツ)\_/¯
```

Replacement in README.md at line 81 [5.12]

B:BD[6.1] → [6.1:77]

- Anyhow works with any error type that has an impl of `std::error::Error`,

[6.1]

[6.77]

- Eyre works with any error type that has an impl of `std::error::Error`,

Replacement in README.md at line 113 [5.12]

B:BD[7.106] → [7.106:184]

depend on Anyhow in no_std mode, disable our default enabled "std" feature in

[7.106]

[7.184]

depend on Eyre in no_std mode, disable our default enabled "std" feature in

Replacement in README.md at line 123 [5.12]

B:BD[7.457] → [7.457:594]

require an explicit `.map_err(Error::msg)` when working with a non-Anyhow error
type inside a function that returns Anyhow's error type.

[7.457]

[7.594]

require an explicit `.map_err(Error::msg)` when working with a non-Eyre error
type inside a function that returns Eyre's error type.

Replacement in README.md at line 141 [5.12]

B:BD[5.436] → [2.29:106]

Use Anyhow if you don't care what error type your functions return, you just

[5.436]

[2.106]

Use Eyre if you don't care what error type your functions return, you just

Replacement in src/context.rs at line 13 [9.642]

B:BD[8.54] → [4.190:263]

        fn ext_context<D>(self, context: D) -> ErrReport<DefaultContext>

[8.54]

[8.107]

        fn ext_report<D>(self, msg: D) -> ErrReport<DefaultContext>

Replacement in src/context.rs at line 23 [9.642]

B:BD[9.1587] → [4.313:386]

        fn ext_context<D>(self, context: D) -> ErrReport<DefaultContext>

[9.1587]

[8.306]

        fn ext_report<D>(self, msg: D) -> ErrReport<DefaultContext>

Replacement in src/context.rs at line 27 [9.642]

B:BD[8.378] → [4.436:487]

            ErrReport::from_context(context, self)

[8.378]

[8.434]

            ErrReport::from_msg(msg, self)

Replacement in src/context.rs at line 32 [9.642]

B:BD[4.538] → [4.538:611]

        fn ext_context<D>(self, context: D) -> ErrReport<DefaultContext>

[4.538]

[8.534]

        fn ext_report<D>(self, msg: D) -> ErrReport<DefaultContext>

Replacement in src/context.rs at line 36 [9.642]
B:BD[8.606] → [8.606:640]
```
            self.context(context)
```
[8.606]
[8.640]
```
            self.wrap_err(msg)
```

Replacement in src/context.rs at line 45 [9.642]

B:BD[8.747] → [4.661:737]

    fn context<D>(self, context: D) -> Result<T, ErrReport<DefaultContext>>

[8.747]

[10.447]

    fn wrap_err<D>(self, msg: D) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 49 [9.642]

B:BD[10.507] → [8.748:805]

        self.map_err(|error| error.ext_context(context))

[10.507]

[9.1917]

        self.map_err(|error| error.ext_report(msg))

Replacement in src/context.rs at line 52 [9.642]

B:BD[9.1924] → [4.783:867]

    fn with_context<D, F>(self, context: F) -> Result<T, ErrReport<DefaultContext>>

[9.1924]

[11.436]

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 57 [9.642]

B:BD[9.2077] → [8.806:865]

        self.map_err(|error| error.ext_context(context()))

[9.2077]

[12.51]

        self.map_err(|error| error.ext_report(msg()))

Replacement in src/context.rs at line 74 [9.642]

B:BD[12.302] → [12.302:357]

///     let t = maybe_get().context("there is no T")?;

[12.302]

[12.357]

///     let t = maybe_get().wrap_err("there is no T")?;

Replacement in src/context.rs at line 82 [9.642]

B:BD[13.195] → [4.939:1015]

    fn context<D>(self, context: D) -> Result<T, ErrReport<DefaultContext>>

[13.195]

[12.570]

    fn wrap_err<D>(self, msg: D) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 86 [9.642]

B:BD[12.630] → [4.1061:1122]

        self.ok_or_else(|| ErrReport::from_display(context))

[12.630]

[9.2167]

        self.ok_or_else(|| ErrReport::from_display(msg))

Replacement in src/context.rs at line 89 [9.642]

B:BD[12.703] → [4.1123:1207]

    fn with_context<D, F>(self, context: F) -> Result<T, ErrReport<DefaultContext>>

[12.703]

[12.767]

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 94 [9.642]

B:BD[12.853] → [4.1279:1342]

        self.ok_or_else(|| ErrReport::from_display(context()))

[12.853]

[12.926]

        self.ok_or_else(|| ErrReport::from_display(msg()))

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

B:BD[14.947] → [4.3258:3321]

    pub(crate) fn from_context<D, E>(msg: D, error: E) -> Self

[14.947]

[15.155]

    pub(crate) fn from_msg<D, E>(msg: D, error: E) -> Self

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

B:BD[16.1438] → [17.2871:2932]

    ///         eyre::ErrReport::new(error).context(context)

[16.1438]

[16.1497]

    ///         eyre::ErrReport::new(error).wrap_err(context)

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

B:BD[16.1534] → [4.4509:4553]

    pub fn context<D>(self, msg: D) -> Self

[16.1534]

[18.499]

    pub fn wrap_err<D>(self, msg: D) -> Self

Replacement in src/lib.rs at line 67 [9.11888]

B:BD[19.741] → [20.379:451]

//!       it.detach().context("Failed to detach the important thing")?;

[19.741]

[21.1149]

//!       it.detach().wrap_err("Failed to detach the important thing")?;

Replacement in src/lib.rs at line 70 [9.11888]

B:BD[21.1197] → [20.452:533]

//!           .with_context(|| format!("Failed to read instrs from {}", path))?;

[21.1197]

[19.742]

//!           .wrap_err_with(|| format!("Failed to read instrs from {}", path))?;

Replacement in src/lib.rs at line 127 [9.11888]

B:BD[6.630] → [6.630:710]

//! - Anyhow works with any error type that has an impl of `std::error::Error`,

[6.630]

[6.710]

//! - Eyre works with any error type that has an impl of `std::error::Error`,

Replacement in src/lib.rs at line 167 [9.11888]

B:BD[7.719] → [7.719:793]

//! To depend on Anyhow in no_std mode, disable our default enabled "std"

[7.719]

[7.793]

//! To depend on Eyre in no_std mode, disable our default enabled "std"

Replacement in src/lib.rs at line 178 [9.11888]

∅:D[17.6920] → [7.1178:1256]

B:BD[7.1178] → [7.1178:1256]

//! non-Anyhow error type inside a function that returns Anyhow's error type.

[17.6920]

[21.2543]

//! non-Eyre error type inside a function that returns Eyre's error type.

Replacement in src/lib.rs at line 275 [9.11888]

B:BD[22.1068] → [17.7522:7581]

///    0: <E as eyre::context::ext::StdError>::ext_context

[22.1068]

[17.7581]

///    0: <E as eyre::context::ext::StdError>::ext_report

Replacement in src/lib.rs at line 279 [9.11888]

B:BD[22.1283] → [13.449:543]

///    2: eyre::context::<impl eyre::Report<T,E> for core::result::Result<T,E>>::with_context

[22.1283]

[17.7727]

///    2: eyre::context::<impl eyre::Report<T,E> for core::result::Result<T,E>>::wrap_err_with

Replacement in src/lib.rs at line 294 [9.11888]

B:BD[22.1748] → [3.380:449]

///     context: "Failed to read instrs from ./path/to/instrs.json",

[22.1748]

[22.1817]

///     msg: "Failed to read instrs from ./path/to/instrs.json",

Replacement in src/lib.rs at line 435 [9.11888]

B:BD[23.84] → [23.84:132]

/// Provides the `context` method for `Result`.

[23.84]

[23.132]

/// Provides the `wrap_err` method for `Result`.

Replacement in src/lib.rs at line 463 [9.11888]

B:BD[23.707] → [20.1061:1131]

///     it.detach().context("Failed to detach the important thing")?;

[23.707]

[23.777]

///     it.detach().wrap_err("Failed to detach the important thing")?;

Replacement in src/lib.rs at line 467 [9.11888]

B:BD[23.847] → [20.1132:1221]

///         .with_context(|| format!("Failed to read instrs from {}", path.display()))?;

[23.847]

[23.936]

///         .wrap_err_with(|| format!("Failed to read instrs from {}", path.display()))?;

Replacement in src/lib.rs at line 490 [9.11888]

B:BD[24.624] → [24.624:702]

/// That is, in codebases that rely on downcasting, Anyhow's context supports

[24.624]

[24.702]

/// That is, in codebases that rely on downcasting, Eyre's context supports

Replacement in src/lib.rs at line 498 [9.11888]

B:BD[24.1019] → [24.1019:1097]

///     break existing working downcasts. In Anyhow, any downcast that worked

[24.1019]

[24.1097]

///     break existing working downcasts. In Eyre, any downcast that worked

Replacement in src/lib.rs at line 518 [9.11888]

B:BD[24.1644] → [20.1283:1345]

///         helper().context("Failed to complete the work")?;

[24.1644]

[24.1706]

///         helper().wrap_err("Failed to complete the work")?;

Replacement in src/lib.rs at line 558 [9.11888]
B:BD[24.2901] → [24.2901:2946]
```
///         helper().context(HelperFailed)?;
```
[24.2901]
[24.2946]
```
///         helper().wrap_err(HelperFailed)?;
```

Replacement in src/lib.rs at line 577 [9.11888]

∅:D[13.795] → [23.1315:1369]

B:BD[23.1315] → [23.1315:1369]

B:BD[23.1369] → [4.12205:12281]

    /// Wrap the error value with additional context.
    fn context<C>(self, context: C) -> Result<T, ErrReport<DefaultContext>>

[13.795]

[23.1425]

    /// Wrap the error value with a new adhoc error
    fn wrap_err<D>(self, msg: D) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/lib.rs at line 580 [9.11888]

B:BD[23.1435] → [23.1435:1479]

        C: Display + Send + Sync + 'static;

[23.1435]

[23.1479]

        D: Display + Send + Sync + 'static;

Replacement in src/lib.rs at line 582 [9.11888]

B:BD[23.1480] → [23.1480:1558]

    /// Wrap the error value with additional context that is evaluated lazily

[23.1480]

[23.1558]

    /// Wrap the error value with a new adhoc error that is evaluated lazily

Replacement in src/lib.rs at line 584 [9.11888]

B:BD[23.1597] → [4.12282:12360]

    fn with_context<C, F>(self, f: F) -> Result<T, ErrReport<DefaultContext>>

[23.1597]

[23.1655]

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/lib.rs at line 586 [9.11888]

B:BD[23.1665] → [23.1665:1735]

        C: Display + Send + Sync + 'static,
        F: FnOnce() -> C;

[23.1665]

[25.155]

        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D;

Replacement in tests/test_boxed.rs at line 37 [26.2018]

B:BD[17.9716] → [17.9716:9770]

    let error = eyre!("oh no!").context("it failed");

[17.9716]

[17.9770]

    let error = eyre!("oh no!").wrap_err("it failed");

Replacement in tests/test_chain.rs at line 4 [27.16]

B:BD[17.9857] → [17.9857:9903]

    eyre!(0).context(1).context(2).context(3)

[17.9857]

[27.117]

    eyre!(0).wrap_err(1).wrap_err(2).wrap_err(3)

Replacement in tests/test_context.rs at line 12 [28.18]
B:BD[28.159] → [28.159:203]
```
    let y: u32 = x.parse().context("...")?;
```
[28.159]
[28.203]
```
    let y: u32 = x.parse().wrap_err("...")?;
```
Replacement in tests/test_context.rs at line 73 [28.18]
B:BD[29.1291] → [29.1291:1319]
```
        .context(MidLevel {
```
[29.1291]
[29.1319]
```
        .wrap_err(MidLevel {
```
Replacement in tests/test_context.rs at line 81 [28.18]
∅:D[17.10075] → [29.1527:1556]
B:BD[29.1527] → [29.1527:1556]
```
        .context(HighLevel {
```
[17.10075]
[29.1556]
```
        .wrap_err(HighLevel {
```
Replacement in tests/test_fmt.rs at line 9 [30.14]
B:BD[30.123] → [30.123:151]
```
    f().context("f failed")
```
[30.123]
[30.151]
```
    f().wrap_err("f failed")
```
Replacement in tests/test_fmt.rs at line 13 [30.14]
B:BD[30.177] → [30.177:205]
```
    g().context("g failed")
```
[30.177]
[30.205]
```
    g().wrap_err("g failed")
```

Replacement in tests/test_source.rs at line 59 [31.17]

B:BD[17.10862] → [4.13588:13651]

    let error: ErrReport = eyre!("oh no!").context("context");

[17.10862]

[17.10914]

    let error: ErrReport = eyre!("oh no!").wrap_err("context");