Skip to content

Commit

Permalink
Merge f586b52 into b6ecfdb
Browse files Browse the repository at this point in the history
  • Loading branch information
@haraldh
haraldh committed Sep 1, 2020
2 parents b6ecfdb + f586b52 commit 19d18b6
Show file tree
Hide file tree
Showing 2 changed files with 125 additions and 344 deletions.
226 changes: 57 additions & 169 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,208 +11,96 @@
`chainerror` provides an error backtrace without doing a real backtrace, so even after you `strip` your
binaries, you still have the error backtrace.

`chainerror` has no dependencies!

`chainerror` uses `.source()` of `std::error::Error` along with `#[track_caller]` and `Location` to provide a nice debug error backtrace.
It encapsulates all types, which have `Display + Debug` and can store the error cause internally.

Along with the `ChainError<T>` struct, `chainerror` comes with some useful helper macros to save a lot of typing.

Debug information is worth it!

### Features
Having nested function returning errors, the output doesn't tell where the error originates from.

`display-cause`
: turn on printing a backtrace of the errors in `Display`

## Tutorial
```rust
use std::path::PathBuf;

Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html)
type BoxedError = Box<dyn std::error::Error + Send + Sync>;
fn read_config_file(path: PathBuf) -> Result<(), BoxedError> {
// do stuff, return other errors
let _buf = std::fs::read_to_string(&path)?;
// do stuff, return other errors
Ok(())
}

## Examples
fn process_config_file() -> Result<(), BoxedError> {
// do stuff, return other errors
let _buf = read_config_file("foo.txt".into())?;
// do stuff, return other errors
Ok(())
}

examples/example.rs:
```rust
// […]
fn main() {
if let Err(e) = func1() {
eprintln!("\nDebug Error {{:?}}:\n{:?}", e);
eprintln!("\nAlternative Debug Error {{:#?}}:\n{:#?}\n", e);
// […]
}
if let Err(e) = process_config_file() {
eprintln!("Error:\n{:?}", e);
}
}
```

This gives the output:
```console
$ cargo run -q --example example
Debug Error {:?}:
examples/example.rs:46:13: func1 error calling func2
Caused by:
examples/example.rs:21:13: Func2Error(func2 error: calling func3)
Caused by:
examples/example.rs:14:18: Error reading 'foo.txt'
Caused by:
Kind(NotFound)

Alternative Debug Error {:#?}:
ChainError<example::Func1Error> {
occurrence: Some(
"examples/example.rs:46:13",
),
kind: func1 error calling func2,
source: Some(
ChainError<example::Func2Error> {
occurrence: Some(
"examples/example.rs:21:13",
),
kind: Func2Error(func2 error: calling func3),
source: Some(
ChainError<alloc::string::String> {
occurrence: Some(
"examples/example.rs:14:18",
),
kind: "Error reading \'foo.txt\'",
source: Some(
Kind(
NotFound,
),
),
},
),
},
),
}
Error:
Os { code: 2, kind: NotFound, message: "No such file or directory" }
```
and you have no idea where it comes from.


With `chainerror`, you can supply a context and get a nice error backtrace:

```rust
use chainerror::prelude::v1::*;
use std::error::Error;
use std::io;
use std::result::Result;
use std::path::PathBuf;

fn do_some_io() -> Result<(), Box<dyn Error + Send + Sync>> {
Err(io::Error::from(io::ErrorKind::NotFound))?;
type BoxedError = Box<dyn std::error::Error + Send + Sync>;
fn read_config_file(path: PathBuf) -> Result<(), BoxedError> {
// do stuff, return other errors
let _buf = std::fs::read_to_string(&path).context(format!("Reading file: {:?}", &path))?;
// do stuff, return other errors
Ok(())
}

fn func2() -> Result<(), Box<dyn Error + Send + Sync>> {
let filename = "foo.txt";
do_some_io().context(format!("Error reading '{}'", filename))?;
fn process_config_file() -> Result<(), BoxedError> {
// do stuff, return other errors
let _buf = read_config_file("foo.txt".into()).context("read the config file")?;
// do stuff, return other errors
Ok(())
}

fn func1() -> Result<(), Box<dyn Error + Send + Sync>> {
func2().context("func1 error")?;
Ok(())
fn main() {
if let Err(e) = process_config_file() {
eprintln!("Error:\n{:?}", e);
}
}
```

if let Err(e) = func1() {
#[cfg(not(windows))]
assert_eq!(
format!("\n{:?}\n", e),
r#"
src/lib.rs:21:13: func1 error
with the output:
```console
Error:
examples/simple.rs:14:51: read the config file
Caused by:
src/lib.rs:16:18: Error reading 'foo.txt'
examples/simple.rs:7:47: Reading file: "foo.txt"
Caused by:
Kind(NotFound)
"#
);
}
Os { code: 2, kind: NotFound, message: "No such file or directory" }
```

`chainerror` uses `.source()` of `std::error::Error` along with `#[track_caller]` and `Location` to provide a nice debug error backtrace.
It encapsulates all types, which have `Display + Debug` and can store the error cause internally.

```rust
use chainerror::prelude::v1::*;
use std::error::Error;
use std::io;
use std::result::Result;

fn do_some_io() -> Result<(), Box<dyn Error + Send + Sync>> {
Err(io::Error::from(io::ErrorKind::NotFound))?;
Ok(())
}

fn func3() -> Result<(), Box<dyn Error + Send + Sync>> {
let filename = "foo.txt";
do_some_io().context(format!("Error reading '{}'", filename))?;
Ok(())
}

derive_str_context!(Func2Error);

fn func2() -> ChainResult<(), Func2Error> {
func3().context(Func2Error("func2 error: calling func3".into()))?;
Ok(())
}

enum Func1Error {
Func2,
IO(String),
}

impl ::std::fmt::Display for Func1Error {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
match self {
Func1Error::Func2 => write!(f, "func1 error calling func2"),
Func1Error::IO(filename) => write!(f, "Error reading '{}'", filename),
}
}
}
Along with the `ChainError<T>` struct, `chainerror` comes with some useful helper macros to save a lot of typing.

impl ::std::fmt::Debug for Func1Error {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "{}", self)
}
}
`chainerror` has no dependencies!

fn func1() -> ChainResult<(), Func1Error> {
func2().context(Func1Error::Func2)?;
let filename = String::from("bar.txt");
do_some_io().context(Func1Error::IO(filename))?;
Ok(())
}
Debug information is worth it!

if let Err(e) = func1() {
assert!(match e.kind() {
Func1Error::Func2 => {
eprintln!("Main Error Report: func1 error calling func2");
true
}
Func1Error::IO(filename) => {
eprintln!("Main Error Report: func1 error reading '{}'", filename);
false
}
});

assert!(e.find_chain_cause::<Func2Error>().is_some());

if let Some(e) = e.find_chain_cause::<Func2Error>() {
eprintln!("\nError reported by Func2Error: {}", e)
}
### Features

assert!(e.root_cause().is_some());
`display-cause`
: turn on printing a backtrace of the errors in `Display`

if let Some(e) = e.root_cause() {
let io_error = e.downcast_ref::<io::Error>().unwrap();
eprintln!("\nThe root cause was: std::io::Error: {:#?}", io_error);
}
## Tutorial

#[cfg(not(windows))]
assert_eq!(
format!("\n{:?}\n", e),
r#"
src/lib.rs:48:13: func1 error calling func2
Caused by:
src/lib.rs:23:13: Func2Error(func2 error: calling func3)
Caused by:
src/lib.rs:16:18: Error reading 'foo.txt'
Caused by:
Kind(NotFound)
"#
);
}
```
Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html)

## License

Expand Down

0 comments on commit 19d18b6

Please sign in to comment.