Anyhow Auto Context

https://docs.rs/anyhow-auto-context/latest/
Admin
Automatic context for anyhow errors based on scope and location, providing detailed error messages...
Tokens:4,983
Snippets:13
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Use auto_context with Option

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context/macro

Demonstrates the usage of the `auto_context` macro with an `Option`. It asserts that the resulting error message starts with the variable name 'expected_some'.

```Rust
let expected_some: Option<()> = None;
let result = auto_context!(expected_some);
assert!(result.unwrap_err().to_string().starts_with("expected_some in"));
```

--------------------------------

### Use auto_context with anyhow::Result

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context/macro

Demonstrates the usage of the `auto_context` macro with an `anyhow::Result`. It asserts that the resulting error message starts with the variable name 'expected_ok'.

```Rust
let expected_ok: anyhow::Result<()> = Err(anyhow::anyhow!("foo_err"));
let result = auto_context!(expected_ok);
assert!(result.unwrap_err().to_string().starts_with("expected_ok in"));
```

--------------------------------

### Rustdoc Search Tricks

Source: https://docs.rs/anyhow-auto-context/latest/help

This section outlines advanced search techniques for Rustdoc, allowing users to refine their searches by item kind, type signature, exact name matching, slice/array parameters, and item paths. These tricks enable more targeted and efficient information retrieval.

```Rustdoc
Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given item kind.
Accepted kinds are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.
Search functions by type signature (e.g., `vec -> usize` or `-> vec` or `String, enum:Cow -> bool`)
You can look for items with an exact name by putting double quotes around your request: `"string"`
Look for functions that accept or return slices and arrays by writing square brackets (e.g., `-> [u8]` or `[] -> Option`)
Look for items inside another one by searching for a path: `vec::Vec`
```

--------------------------------

### Rustdoc Keyboard Shortcuts

Source: https://docs.rs/anyhow-auto-context/latest/help

This snippet lists the primary keyboard shortcuts available in Rustdoc for navigating the documentation interface and interacting with search functionality. These shortcuts enhance user efficiency when browsing Rust API references.

```Rustdoc
`?`
    Show this help dialog 

`S` / `/` 
    Focus the search field 

`↑`
    Move up in search results 

`↓`
    Move down in search results 

`←` / `→` 
    Switch result tab (when results focused) 

`⏎`
    Go to active search result 

`+`
    Expand all sections 

`-`
    Collapse all sections
```

--------------------------------

### Use anyhow-auto-context macro

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context/all

This snippet demonstrates the usage of the `auto_context` macro provided by the anyhow-auto-context crate. This macro is designed to simplify context management within Rust applications, likely integrating with the `anyhow` error handling library.

```Rust
use anyhow_auto_context::auto_context;

#[auto_context("My operation failed")]
fn perform_operation() -> Result<(), anyhow::Error> {
    // ... operation logic ...
    Ok(())
}
```

--------------------------------

### Usage with Option in Rust

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context/index

Demonstrates how to use the `auto_context` macro with an `Option` type in Rust. It shows how an `Option` being `None` can be automatically converted into an `anyhow` error with context.

```Rust
use anyhow_auto_context::auto_context;

fn main() -> anyhow::Result<()> {
    let expected_some = None;
    auto_context!(expected_some)
}
```

--------------------------------

### Usage with Option in Rust

Source: https://docs.rs/anyhow-auto-context/latest/index

Demonstrates how to use the `auto_context` macro with an `Option` type in Rust. It shows how an `Option` being `None` can be automatically converted into an `anyhow` error with context.

```Rust
use anyhow_auto_context::auto_context;

fn main() -> anyhow::Result<()> {
    let expected_some = None;
    auto_context!(expected_some)
}
```

--------------------------------

### Usage with Option in Rust

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context

Demonstrates how to use the `auto_context` macro with an `Option` type in Rust. It shows how an `Option` being `None` can be automatically converted into an `anyhow` error with context.

```Rust
use anyhow_auto_context::auto_context;

fn main() -> anyhow::Result<()> {
    let expected_some = None;
    auto_context!(expected_some)
}
```

--------------------------------

### Usage with Result in Rust

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context/index

Illustrates the use of the `auto_context` macro with `Result` types in Rust. It shows how errors are propagated and context is automatically added at each step of the call stack.

```Rust
use anyhow::Result;
use anyhow_auto_context::auto_context;

fn main() -> Result<()> {
    auto_context!(foo())
}

fn foo() -> Result<()> {
    auto_context!(bar())
}

fn bar() -> Result<()> {
    anyhow::bail!("my error")
}
```

--------------------------------

### Usage with Result in Rust

Source: https://docs.rs/anyhow-auto-context/latest/index

Illustrates the use of the `auto_context` macro with `Result` types in Rust. It shows how errors are propagated and context is automatically added at each step of the call stack.

```Rust
use anyhow::Result;
use anyhow_auto_context::auto_context;

fn main() -> Result<()> {
    auto_context!(foo())
}

fn foo() -> Result<()> {
    auto_context!(bar())
}

fn bar() -> Result<()> {
    anyhow::bail!("my error")
}
```

--------------------------------

### Usage with Result in Rust

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context

Illustrates the use of the `auto_context` macro with `Result` types in Rust. It shows how errors are propagated and context is automatically added at each step of the call stack.

```Rust
use anyhow::Result;
use anyhow_auto_context::auto_context;

fn main() -> Result<()> {
    auto_context!(foo())
}

fn foo() -> Result<()> {
    auto_context!(bar())
}

fn bar() -> Result<()> {
    anyhow::bail!("my error")
}
```

--------------------------------

### Define auto_context macro

Source: https://docs.rs/anyhow-auto-context/latest/anyhow_auto_context/macro

Defines the `auto_context` macro which adds automatic anyhow context based on scope and location. It takes an expression that evaluates to a Result.

```Rust
macro_rules! auto_context {
    ($result:expr_2021) => { ... };
}
```

--------------------------------

### Add Automatic Context to Anyhow Errors (Rust)

Source: https://docs.rs/anyhow-auto-context/latest/src/anyhow_auto_context/lib

The `auto_context!` macro enhances `anyhow::Context` by automatically including the expression string, scope, file, line, and column number in the error context. This helps in debugging by providing more detailed information about where an error occurred.

```Rust
#![doc = include_str!("../README.md")]

/// Adds automatic `anyhow` context based on scope and location
///
/// ```
/// # use anyhow_auto_context::auto_context;
///
/// let expected_some: Option<()> = None;
/// let result = auto_context!(expected_some);
/// assert!(result.unwrap_err().to_string().starts_with("expected_some in"));
///
/// let expected_ok: anyhow::Result<()> = Err(anyhow::anyhow!("foo_err"));
/// let result = auto_context!(expected_ok);
/// assert!(result.unwrap_err().to_string().starts_with("expected_ok in"));
/// ```
#[macro_export]
macro_rules! auto_context {
    ($result:expr_2021) => {
        anyhow::Context::with_context($result, || {
            const fn f() {}
            fn type_name<T>(_: T) -> &'static str {
                ::std::any::type_name::<T>()
            }
            let scope = type_name(f)
                .strip_suffix("::f")
                .unwrap_or_default()
                .trim_end_matches("::{{closure}}");
            format!(
                "{} in {} at {}:{}:{}",
                stringify!($result),
                scope,
                file!(),
                line!(),
                column!(),
            )
        })
    };
}

#[cfg(test)]
mod tests {
    use super::*;

    fn ensure_42(n: i32) -> anyhow::Result<()> {
        anyhow::ensure!(n == 42, "Expected 42");
        Ok(())
    }

    #[test]
    fn ok() {
        assert!(auto_context!(ensure_42(42)).is_ok());
    }

    #[test]
    fn err() {
        let err_str = auto_context!(ensure_42(0)).unwrap_err().to_string();
        assert!(err_str.starts_with("ensure_42(0) in"), "{err_str}");
    }

    #[test]
    fn some() {
        assert_eq!(auto_context!(Some(42)).unwrap(), 42);
    }

    #[test]
    fn none() {
        let expected_some: Option<i32> = None;

        let err_str = auto_context!(expected_some).unwrap_err().to_string();
        assert!(err_str.starts_with("expected_some in"), "{err_str}");
    }
}
```
Tokens:
Raw