### Get differ for path

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Determines the appropriate diff function based on the file extension.

```APIDOC
## get_differ_for_path<P: AsRef<Path>>(_path: P) -> Differ

### Description
Get the diff function to use for a given file path. It defaults to text_diff for unknown extensions.

### Parameters
#### Path Parameters
- **_path** (P: AsRef<Path>) - Required - The path of the file.

### Returns
- Differ - The selected diff function.
```

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

### Get File Length

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

Retrieves the length of a file in bytes. It uses `fs::metadata` and panics if there's an error during metadata retrieval.

```rust
fn file_len(path: &Path) -> u64 {
    check_io(fs::metadata(path), "getting file length", path).len()
}
```

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

### get_differ_for_path

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/fn.get_differ_for_path.html

Get the diff function to use for a given file path.

```APIDOC
## Function get_differ_for_path

### Description
Get the diff function to use for a given file path.

### Signature
```rust
pub fn get_differ_for_path<P: AsRef<Path>>(_path: P) -> Differ
```

### Parameters
* `_path`: A type `P` that implements `AsRef<Path>`, representing the file path.

### Returns
A `Differ` object representing the diff function for the given path.
```

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

### Create a new goldenfile Mint

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Initializes a new Mint instance, creating the goldenfile directory if it doesn't exist. Panics if directory creation fails.

```rust
pub struct Mint {
    path: PathBuf,
    tempdir: TempDir,
    files: Vec<(PathBuf, Differ)>,
    create_empty: bool,
}

impl Mint {
    fn new_internal<P: AsRef<Path>>(path: P, create_empty: bool) -> Self {
        let path = path.as_ref().to_path_buf();
        let tempdir = TempDir::new().unwrap();
        let mint = Mint {
            path,
            files: vec![],
            tempdir,
            create_empty,
        };
        fs::create_dir_all(&mint.path).unwrap_or_else(|err| {
            panic!(
                "Failed to create goldenfile directory {:?}: {:?",
                mint.path,
                err
            )
        });

        mint
    }

    /// Create a new goldenfile Mint.
    pub fn new<P: AsRef<Path>>(path: P) -> Self {
        Self::new_internal(path, true)
    }

    /// Create a new goldenfile Mint. Goldenfiles will only be created when non-empty.
    pub fn new_nonempty<P: AsRef<Path>>(path: P) -> Self {
        Self::new_internal(path, false)
    }
}
```

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

### Mint::new

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Creates a new goldenfile Mint. Goldenfiles will be created even if they are empty.

```APIDOC
## Mint::new

### Description
Creates a new goldenfile Mint. Goldenfiles will be created even if they are empty.

### Signature
```rust
pub fn new<P: AsRef<Path>>(path: P) -> Self
```

### Parameters
* `path` (P: AsRef<Path>) - The directory path where goldenfiles will be stored.
```

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

### Set Background Color using `bg()` or `on_red()`

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Demonstrates setting the background color. Prefer using specific methods like `on_red()` over the general `bg()` method for conciseness.

```rust
use yansi::{Paint, Color};

painted.bg(Color::Red);
```

```rust
use yansi::Paint;

painted.on_red();
```

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

### new

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Creates a new `Painted` object with a default `Style`.

```APIDOC
## new

### Description
Create a new `Painted` with a default `Style`.

### Method Signature
`fn new(self) -> Painted<Self>`

### Constraints
`Self: Sized`

### Returns
- `Painted<Self>` - A new `Painted` object with default styling.

### Example
```rust
// Assuming 'Painted' is a type that can be created with new()
let default_painted = Painted::new();
```
```

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

### Mint::new

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Creates a new goldenfile Mint, which will manage goldenfiles in the specified path.

```APIDOC
## Mint::new

### Description
Create a new goldenfile Mint.

### Signature
```rust
pub fn new<P: AsRef<Path>>(path: P) -> Self
```
```

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

### Create New Mint

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Initializes a new Mint instance for managing golden files at the specified path. Use this when you want to create or update golden files.

```rust
pub fn new<P: AsRef<Path>>(path: P) -> Self
```

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

### Mint::new_nonempty

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Creates a new goldenfile Mint. Goldenfiles will only be created when non-empty.

```APIDOC
## Mint::new_nonempty

### Description
Creates a new goldenfile Mint. Goldenfiles will only be created when non-empty.

### Signature
```rust
pub fn new_nonempty<P: AsRef<Path>>(path: P) -> Self
```

### Parameters
* `path` (P: AsRef<Path>) - The directory path where goldenfiles will be stored.
```

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

### Create New Non-Empty Mint

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Initializes a new Mint instance that only creates golden files when the content is non-empty. This is useful for avoiding empty files.

```rust
pub fn new_nonempty<P: AsRef<Path>>(path: P) -> Self
```

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

### Generate and Write to Goldenfiles

Source: https://docs.rs/goldenfile/latest/goldenfile/index.html

Use Mint to create new goldenfiles and write content to them. The comparison with checked-in versions happens when Mint goes out of scope.

```rust
use goldenfile::Mint;
use std::io::Write;

let mut mint = Mint::new("tests/goldenfiles");
let mut file1 = mint.new_goldenfile("file1.txt").unwrap();
let mut file2 = mint.new_goldenfile("file2.txt").unwrap();

writeln!(file1, "Hello world!").unwrap();
writeln!(file2, "Foo bar!").unwrap();
```

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

### Mint::new_goldenfile

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Creates a new goldenfile using a differ inferred from the file extension. The returned File is a temporary file, not the goldenfile itself.

```APIDOC
## Mint::new_goldenfile

### Description
Creates a new goldenfile using a differ inferred from the file extension. The returned File is a temporary file, not the goldenfile itself.

### Signature
```rust
pub fn new_goldenfile<P: AsRef<Path>>(&mut self, path: P) -> Result<File>
```

### Parameters
* `path` (P: AsRef<Path>) - The path to the goldenfile relative to the mint's base path.

### Returns
* `Result<File>` - A `File` handle to the temporary goldenfile.
```

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

### Mint::new_goldenfile_with_differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Creates a new goldenfile with the specified diff function. The returned File is a temporary file, not the goldenfile itself.

```APIDOC
## Mint::new_goldenfile_with_differ

### Description
Creates a new goldenfile with the specified diff function. The returned File is a temporary file, not the goldenfile itself.

### Signature
```rust
pub fn new_goldenfile_with_differ<P: AsRef<Path>>(&mut self, path: P, differ: Differ) -> Result<File>
```

### Parameters
* `path` (P: AsRef<Path>) - The path to the goldenfile relative to the mint's base path.
* `differ` (Differ) - The differ function to use for comparing goldenfiles.

### Returns
* `Result<File>` - A `File` handle to the temporary goldenfile.
```

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

### Paint white() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to white using the `white()` method. This is a shorthand for `fg(Color::White)`.

```rust
use yansi::Paint;

painted.white();
```

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

### Generate and Compare Golden Files in Rust

Source: https://docs.rs/goldenfile/latest/src/goldenfile/lib.rs.html

Use `Mint::new` to create a goldenfile manager and `new_goldenfile` to create or open files for writing. The comparison happens automatically when the `Mint` object goes out of scope. To update golden files, set the `UPDATE_GOLDENFILES` environment variable.

```rust
use goldenfile::Mint;
use std::io::Write;

let mut mint = Mint::new("tests/goldenfiles");
let mut file1 = mint.new_goldenfile("file1.txt").unwrap();
let mut file2 = mint.new_goldenfile("file2.txt").unwrap();

writeln!(file1, "Hello world!").unwrap();
writeln!(file2, "Foo bar!").unwrap();

```

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

### Compare Binary Files

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

Compares two files byte by byte. Panics if file sizes differ or if any byte mismatch is found, reporting the first differing byte's position.

```rust
pub fn binary_diff(old: &Path, new: &Path) {
    let old_len = file_len(old);
    let new_len = file_len(new);
    if old_len != new_len {
        panic!(
            "File sizes differ: Old file is {} bytes, new file is {} bytes",
            old_len, new_len
        );
    }

    let first_difference = file_byte_iter(old)
        .zip(file_byte_iter(new))
        .position(|(old_byte, new_byte)| old_byte != new_byte);

    if let Some(position) = first_difference {
        panic!({"Files differ at byte {}", old.display(), position + 1});
    }
}
```

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

### whenever

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Conditionally enables styling based on a `Condition`. Replaces any previous condition.

```APIDOC
## whenever

### Description
Conditionally enable styling based on whether the `Condition` `value` applies. Replaces any previous condition.
See the crate level docs for more details.

### Method Signature
`fn whenever(&self, value: Condition) -> Painted<&T>`

### Parameters
- **value** (`Condition`) - Description: The condition to check for enabling the style.

### Returns
- `Painted<&T>` - A `Painted` object with the conditional styling applied.

### Example
```rust
use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
```
```

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

### Paint green() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to green using the `green()` method. This is a shorthand for `fg(Color::Green)`.

```rust
println!("{}", value.green());
```

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

### Create a new goldenfile with specified differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Creates a new temporary file for writing goldenfile content using a provided differ. Ensures the parent directory for the temporary file exists. Returns a `Result<File>` which is the temporary file.

```rust
/// Create a new goldenfile with the specified diff function.
///
/// The returned File is a temporary file, not the goldenfile itself.
pub fn new_goldenfile_with_differ<
    P: AsRef<Path>,
>(
    &mut self,
    path: P,
    differ: Differ,
) -> Result<File> {
    let abs_path = self.new_goldenpath_with_differ(path, differ)?;
    if let Some(abs_parent) = abs_path.parent() && abs_parent != self.tempdir.path() {
        fs::create_dir_all(abs_parent).unwrap_or_else(|err| {
            panic!(
                "Failed to create temporary subdirectory {:?}: {:?",
                abs_parent,
                err
            )
        });
    }

    let maybe_file = File::create(abs_path);
    if maybe_file.is_err() {
        self.files.pop();
    }

    maybe_file
}
```

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

### paint

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Applies a style wholesale to the object, replacing any previous style.

```APIDOC
## paint

### Description
Apply a style wholesale to `self`. Any previous style is replaced.

### Method Signature
`fn paint<S>(&self, style: S) -> Painted<&Self>`

### Constraints
`S: Into<Style>`

### Parameters
- **style** (`S`) - Description: The style to apply. Must be convertible into a `Style`.

### Returns
- `Painted<&Self>` - A `Painted` object with the specified style applied.

### Example
```rust
// Assuming 'painted_object' is a mutable reference to a type that has a 'paint' method
let styled_object = painted_object.paint(Style::new().red().bold());
```
```

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

### Paint primary() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to `Color::Primary` using the `primary()` method. This is a shorthand for `fg(Color::Primary)`.

```rust
println!("{}", value.primary());
```

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

### Paint black() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to black using the `black()` method. This is a shorthand for `fg(Color::Black)`.

```rust
println!("{}", value.black());
```

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

### Paint red() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to red using the `red()` method. This is a shorthand for `fg(Color::Red)`.

```rust
println!("{}", value.red());
```

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

### Create a new goldenfile using inferred differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Creates a new temporary file for writing goldenfile content, inferring the differ based on the file extension. Returns a `Result<File>` which is the temporary file.

```rust
/// Create a new goldenfile using a differ inferred from the file extension.
///
/// The returned File is a temporary file, not the goldenfile itself.
pub fn new_goldenfile<P: AsRef<Path>>(&mut self, path: P) -> Result<File> {
    self.new_goldenfile_with_differ(&path, get_differ_for_path(&path))
}
```

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

### binary_diff

Source: https://docs.rs/goldenfile/latest/goldenfile/differs/fn.binary_diff.html

Compares two binary files and panics if they differ with some basic information about where they differ.

```APIDOC
## Function binary_diff

### Description

Panic if binary files differ with some basic information about where they differ.

### Signature

```rust
pub fn binary_diff(old: &Path, new: &Path)
```

### Parameters

* `old` - A reference to the `Path` of the old binary file.
* `new` - A reference to the `Path` of the new binary file.
```

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

### Paint rgb() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to an RGB value using the `rgb()` method. This is a shorthand for `fg(Color::Rgb(r, g, b))`.

```rust
println!("{}", value.rgb(r, g, b));
```

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

### Mint::new_goldenpath

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Registers a new goldenfile using a differ inferred from the file extension. The returned PathBuf references a temporary file, not the goldenfile itself.

```APIDOC
## Mint::new_goldenpath

### Description
Register a new goldenfile using a differ inferred from the file extension.
The returned PathBuf references a temporary file, not the goldenfile itself.

### Signature
```rust
pub fn new_goldenpath<P: AsRef<Path>>(&mut self, path: P) -> Result<PathBuf>
```
```

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

### Helper Function for File I/O Operations

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

A utility function to open a file, handling potential I/O errors by panicking with a descriptive message.

```rust
fn open_file(path: &Path) -> fs::File {
    check_io(fs::File::open(path), "opening file", path)
}
```

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

### Background Color Methods

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

These methods set the background color of the painted text.

```APIDOC
## bg(value: Color)

### Description
Returns a styled value derived from `self` with the background set to `value`. This method should be used rarely. Instead, prefer to use color-specific builder methods like `on_red()` and `on_green()`, which have the same functionality but are pithier.

### Method
`bg(value: Color)`

### Parameters
#### Path Parameters
- **value** (Color) - Required - The color to set as the background.

### Example
```rust
use yansi::{Paint, Color};

painted.bg(Color::Red);
```
```

```APIDOC
## on_primary()

### Description
Returns `self` with the `bg()` set to [`Color :: Primary`].

### Method
`on_primary()`

### Example
```rust
println!("{}", value.on_primary());
```
```

```APIDOC
## on_fixed(color: u8)

### Description
Returns `self` with the `bg()` set to [`Color :: Fixed`].

### Method
`on_fixed(color: u8)`

### Parameters
#### Path Parameters
- **color** (u8) - Required - The fixed color value.

### Example
```rust
println!("{}", value.on_fixed(color));
```
```

```APIDOC
## on_rgb(r: u8, g: u8, b: u8)

### Description
Returns `self` with the `bg()` set to [`Color :: Rgb`].

### Method
`on_rgb(r: u8, g: u8, b: u8)`

### Parameters
#### Path Parameters
- **r** (u8) - Required - The red component of the RGB color.
- **g** (u8) - Required - The green component of the RGB color.
- **b** (u8) - Required - The blue component of the RGB color.

### Example
```rust
println!("{}", value.on_rgb(r, g, b));
```
```

```APIDOC
## on_black()

### Description
Returns `self` with the `bg()` set to [`Color :: Black`].

### Method
`on_black()`

### Example
```rust
println!("{}", value.on_black());
```
```

```APIDOC
## on_red()

### Description
Returns `self` with the `bg()` set to [`Color :: Red`].

### Method
`on_red()`

### Example
```rust
println!("{}", value.on_red());
```
```

```APIDOC
## on_green()

### Description
Returns `self` with the `bg()` set to [`Color :: Green`].

### Method
`on_green()`

### Example
```rust
println!("{}", value.on_green());
```
```

```APIDOC
## on_yellow()

### Description
Returns `self` with the `bg()` set to [`Color :: Yellow`].

### Method
`on_yellow()`

### Example
```rust
println!("{}", value.on_yellow());
```
```

```APIDOC
## on_blue()

### Description
Returns `self` with the `bg()` set to [`Color :: Blue`].

### Method
`on_blue()`

### Example
```rust
println!("{}", value.on_blue());
```
```

```APIDOC
## on_magenta()

### Description
Returns `self` with the `bg()` set to [`Color :: Magenta`].

### Method
`on_magenta()`

### Example
```rust
println!("{}", value.on_magenta());
```
```

```APIDOC
## on_cyan()

### Description
Returns `self` with the `bg()` set to [`Color :: Cyan`].

### Method
`on_cyan()`

### Example
```rust
println!("{}", value.on_cyan());
```
```

```APIDOC
## on_white()

### Description
Returns `self` with the `bg()` set to [`Color :: White`].

### Method
`on_white()`

### Example
```rust
println!("{}", value.on_white());
```
```

```APIDOC
## on_bright_black()

### Description
Returns `self` with the `bg()` set to [`Color :: BrightBlack`].

### Method
`on_bright_black()`

### Example
```rust
println!("{}", value.on_bright_black());
```
```

```APIDOC
## on_bright_red()

### Description
Returns `self` with the `bg()` set to [`Color :: BrightRed`].

### Method
`on_bright_red()`

### Example
```rust
println!("{}", value.on_bright_red());
```
```

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

### Compare Unicode Text Files with Diff

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

Compares two files as UTF-8 encoded text. If they differ, it prints a colored diff and panics. Falls back to binary comparison if UTF-8 decoding fails.

```rust
pub fn text_diff(old: &Path, new: &Path) {
    let old_str = String::from_utf8(check_io(fs::read(old), "reading file", old));
    let new_str = String::from_utf8(check_io(fs::read(new), "reading file", new));

    match (old_str, new_str) {
        (Ok(old_str), Ok(new_str)) => {
            similar_asserts::assert_eq!(&old_str, &new_str, "{}", old.display())
        }
        _ => binary_diff(old, new),
    }
}
```

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

### Create New Goldenfile with Differ

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Creates a new golden file using a specified differ function. The returned File is temporary and needs to be written to.

```rust
pub fn new_goldenfile_with_differ<P: AsRef<Path>>(
  &mut self,
  path: P,
  differ: Differ,
) -> Result<File>
```

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

### binary_diff

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

Compares two files as binary. It first checks if the file sizes are equal. If they are not, it panics with the differing sizes. If the sizes are equal, it iterates through the bytes of both files to find the first differing byte and panics with the position of the difference.

```APIDOC
## binary_diff

### Description
Compares two files as binary. It first checks if the file sizes are equal. If they are not, it panics with the differing sizes. If the sizes are equal, it iterates through the bytes of both files to find the first differing byte and panics with the position of the difference.

### Function Signature
```rust
pub fn binary_diff(old: &Path, new: &Path)
```

### Parameters
- **old** (`&Path`): A reference to the path of the old file.
- **new** (`&Path`): A reference to the path of the new file.
```

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

### Mint::new_goldenpath_with_differ

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Registers a new goldenfile with the specified diff function. The returned PathBuf references a temporary file, not the goldenfile itself.

```APIDOC
## Mint::new_goldenpath_with_differ

### Description
Register a new goldenfile with the specified diff function.
The returned PathBuf references a temporary file, not the goldenfile itself.

### Signature
```rust
pub fn new_goldenpath_with_differ<P: AsRef<Path>>( &mut self, path: P, differ: Differ, ) -> Result<PathBuf>
```
```

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

### text_diff

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

Compares two files as text. It reads both files, attempts to decode them as UTF-8, and uses `similar_asserts::assert_eq!` to compare their content. If decoding fails, it falls back to `binary_diff`.

```APIDOC
## text_diff

### Description
Compares two files as text. It reads both files, attempts to decode them as UTF-8, and uses `similar_asserts::assert_eq!` to compare their content. If decoding fails, it falls back to `binary_diff`.

### Function Signature
```rust
pub fn text_diff(old: &Path, new: &Path)
```

### Parameters
- **old** (`&Path`): A reference to the path of the old file.
- **new** (`&Path`): A reference to the path of the new file.
```

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

### Paint fixed() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color to a fixed color value using the `fixed()` method. This is a shorthand for `fg(Color::Fixed(color))`.

```rust
println!("{}", value.fixed(color));
```

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

### Check Goldenfiles

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Compares newly written golden file contents against existing ones. Panics if differences are found. This is automatically called when a Mint goes out of scope if UPDATE_GOLDENFILES is not set to '1'.

```rust
pub fn check_goldenfiles(&self)
```

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

### Register New Goldenfile with Inferred Differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Use this function to register a new goldenfile. The differ strategy is automatically determined based on the file extension. The returned path points to a temporary file for writing.

```rust
pub fn new_goldenpath<P: AsRef<Path>>(&mut self, path: P) -> Result<PathBuf> {
        self.new_goldenpath_with_differ(&path, get_differ_for_path(&path))
    }
```

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

### Apply Quirk using quirk()

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Enables a specific quirk for the painted text. Prefer quirk-specific builder methods like `wrap()` for clarity and conciseness.

```rust
use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);
```

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

### on_bright_white

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the background color set to `Color::BrightWhite`.

```APIDOC
## fn on_bright_white(&self) -> Painted<&T>

### Description
Returns `self` with the `bg()` set to [`Color :: BrightWhite`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.on_bright_white());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Check goldenfiles for differences

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Compares new goldenfile contents with existing ones. If differences are found and `UPDATE_GOLDENFILES` is not '1', it prints an error and panics. This is called automatically when a `Mint` goes out of scope.

```rust
/// Check new goldenfile contents against old, and panic if they differ.
///
/// Called automatically when a Mint goes out of scope and
/// `UPDATE_GOLDENFILES!=1`.
pub fn check_goldenfiles(&self) {
    for (file, differ) in &self.files {
        let old = self.path.join(file);
        let new = self.tempdir.path().join(file);
        defer_on_unwind! {
            eprintln!("note: run with `UPDATE_GOLDENFILES=1` to update goldenfiles");
            eprintln!(
                "{}: goldenfile changed: {}",
                "error".bold().red(),
                file.to_str().unwrap()
            );
        }
        differ(&old, &new);
    }
}
```

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

### Enable Wrapping using wrap()

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns the painted text with the wrap quirk enabled. This is a convenience method for `quirk(Quirk::Wrap)`.

```rust
use yansi::Paint;

painted.wrap();
```

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

### on_bright_cyan

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the background color set to `Color::BrightCyan`.

```APIDOC
## fn on_bright_cyan(&self) -> Painted<&T>

### Description
Returns `self` with the `bg()` set to [`Color :: BrightCyan`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.on_bright_cyan());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### attr

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Enables the styling `Attribute` `value`. Prefer attribute-specific builder methods like `bold()` and `underline()`.

```APIDOC
## fn attr(&self, value: Attribute) -> Painted<&T>

### Description
Enables the styling `Attribute` `value`. This method should be used rarely. Instead, prefer to use attribute-specific builder methods like `bold()` and `underline()`.

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
- **value** (`Attribute`): The attribute to enable.

### Request Example
Make text bold using `attr()`:
```rust
use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Infer Differ Strategy Based on File Extension

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

This function determines the appropriate diffing strategy (binary or text) based on the file's extension. Binary diffing is used for common archive and executable formats, while text diffing is the default.

```rust
pub fn get_differ_for_path<P: AsRef<Path>>(_path: P) -> Differ {
    match _path.as_ref().extension() {
        Some(os_str) => match os_str.to_str() {
            Some("bin") => Box::new(binary_diff),
            Some("exe") => Box::new(binary_diff),
            Some("gz") => Box::new(binary_diff),
            Some("pcap") => Box::new(binary_diff),
            Some("tar") => Box::new(binary_diff),
            Some("zip") => Box::new(binary_diff),
            _ => Box::new(text_diff),
        },
        _ => Box::new(text_diff),
    }
}
```

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

### Register a new goldenfile with inferred differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Registers a new goldenfile using a differ inferred from the file extension. The returned PathBuf references a temporary file, not the goldenfile itself.

```APIDOC
## new_goldenpath<P: AsRef<Path>>(&mut self, path: P) -> Result<PathBuf>

### Description
Registers a new goldenfile using a differ inferred from the file extension. The returned PathBuf references a temporary file, not the goldenfile itself.

### Parameters
#### Path Parameters
- **path** (P: AsRef<Path>) - Required - The path to the goldenfile.

### Returns
- Result<PathBuf> - A PathBuf referencing a temporary file.
```

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

### Register a new goldenfile with a specified differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Registers a new goldenfile with the specified diff function. The returned PathBuf references a temporary file, not the goldenfile itself.

```APIDOC
## new_goldenpath_with_differ<P: AsRef<Path>>(&mut self, path: P, differ: Differ) -> Result<PathBuf>

### Description
Registers a new goldenfile with the specified diff function. The returned PathBuf references a temporary file, not the goldenfile itself.

### Parameters
#### Path Parameters
- **path** (P: AsRef<Path>) - Required - The path to the goldenfile.
- **differ** (Differ) - Required - The diff function to use for this goldenfile.

### Returns
- Result<PathBuf> - A PathBuf referencing a temporary file.

### Errors
- ErrorKind::InvalidInput - If the provided path is not relative.
```

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

### on_bright_blue

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the background color set to `Color::BrightBlue`.

```APIDOC
## fn on_bright_blue(&self) -> Painted<&T>

### Description
Returns `self` with the `bg()` set to [`Color :: BrightBlue`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.on_bright_blue());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Paint fg() Method

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Sets the foreground color of a painted string using the `fg` method. This method should be used sparingly, preferring color-specific methods like `red()` or `white()`.

```rust
use yansi::{Paint, Color};

painted.fg(Color::White);
```

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

### on_bright_green

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the background color set to `Color::BrightGreen`.

```APIDOC
## fn on_bright_green(&self) -> Painted<&T>

### Description
Returns `self` with the `bg()` set to [`Color :: BrightGreen`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.on_bright_green());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Update goldenfiles with new content

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Overwrites existing goldenfiles with their new contents from the temporary directory. Supports running under Bazel by checking the `BUILD_WORKSPACE_DIRECTORY` environment variable. Skips updating if the new file is empty and `create_empty` is false.

```rust
/// Overwrite old goldenfile contents with their new contents.
///
/// Called automatically when a Mint goes out of scope and
/// `UPDATE_GOLDENFILES=1`.
pub fn update_goldenfiles(&self) {
    // Support running under Bazel.
    let path = match std::env::var("BUILD_WORKSPACE_DIRECTORY") {
        Ok(workspace) => PathBuf::from(workspace).join(&self.path),
        Err(_) => self.path.clone(),
    };

    for (file, _) in &self.files {
        let old = path.join(file);
        let new = self.tempdir.path().join(file);

        let empty = File::open(&new).unwrap().metadata().unwrap().len() == 0;
        if self.create_empty || !empty {
            println!("Updating {:?}.", file.to_str().unwrap());
            fs::copy(&new, &old).unwrap_or_else(|err| {
                panic!("Error copying {:?} to {:?}: {:?", &new, &old, err)
            });
        } else if old.exists() {
            // If the old file exists and the new one is empty, and we don't want
            // empty files, then we should delete the old file.
            fs::remove_file(old).unwrap_or_else(|err| {
                panic!("Error removing {:?}: {:?", old, err)
            });
        }
    }
}
```

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

### Set Background to Bright Cyan

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Use this method to set the background color of the painted text to Bright Cyan. This is a convenience method for setting the background color.

```rust
println!("{}", value.on_bright_cyan());
```

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

### Apply Attribute using attr()

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Enables a specific styling attribute. Prefer attribute-specific builder methods like `bold()` for clarity and conciseness.

```rust
use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);
```

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

### Mint::check_goldenfiles

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Checks new goldenfile contents against old, and panics if they differ. Called automatically when a Mint goes out of scope and `UPDATE_GOLDENFILES!=1`.

```APIDOC
## Mint::check_goldenfiles

### Description
Checks new goldenfile contents against old, and panics if they differ. Called automatically when a Mint goes out of scope and `UPDATE_GOLDENFILES!=1`.

### Signature
```rust
pub fn check_goldenfiles(&self)
```
```

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

### Conditional Styling with `whenever`

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Conditionally apply styling based on a `Condition`. Replaces any previous condition.

```rust
use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
```

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

### binary_diff Function Signature

Source: https://docs.rs/goldenfile/latest/goldenfile/differs/fn.binary_diff.html

This function takes two paths to binary files and panics if they are not identical. It provides basic information about where the differences occur.

```rust
pub fn binary_diff(old: &Path, new: &Path)
```

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

### Set Background to Bright White

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Use this method to set the background color of the painted text to Bright White. This is a convenience method for setting the background color.

```rust
println!("{}", value.on_bright_white());
```

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

### resetting

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the `quirk()` set to `Quirk::Resetting`.

```APIDOC
## fn resetting(&self) -> Painted<&T>

### Description
Returns `self` with the `quirk()` set to [`Quirk :: Resetting`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.resetting());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### on_bright_magenta

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the background color set to `Color::BrightMagenta`.

```APIDOC
## fn on_bright_magenta(&self) -> Painted<&T>

### Description
Returns `self` with the `bg()` set to [`Color :: BrightMagenta`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.on_bright_magenta());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Foreground Color Methods

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

These methods set the foreground color of the painted text.

```APIDOC
## yellow()

### Description
Returns `self` with the `fg()` set to [`Color :: Yellow`].

### Method
`yellow()`

### Example
```rust
println!("{}", value.yellow());
```
```

```APIDOC
## blue()

### Description
Returns `self` with the `fg()` set to [`Color :: Blue`].

### Method
`blue()`

### Example
```rust
println!("{}", value.blue());
```
```

```APIDOC
## magenta()

### Description
Returns `self` with the `fg()` set to [`Color :: Magenta`].

### Method
`magenta()`

### Example
```rust
println!("{}", value.magenta());
```
```

```APIDOC
## cyan()

### Description
Returns `self` with the `fg()` set to [`Color :: Cyan`].

### Method
`cyan()`

### Example
```rust
println!("{}", value.cyan());
```
```

```APIDOC
## white()

### Description
Returns `self` with the `fg()` set to [`Color :: White`].

### Method
`white()`

### Example
```rust
println!("{}", value.white());
```
```

```APIDOC
## bright_black()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightBlack`].

### Method
`bright_black()`

### Example
```rust
println!("{}", value.bright_black());
```
```

```APIDOC
## bright_red()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightRed`].

### Method
`bright_red()`

### Example
```rust
println!("{}", value.bright_red());
```
```

```APIDOC
## bright_green()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightGreen`].

### Method
`bright_green()`

### Example
```rust
println!("{}", value.bright_green());
```
```

```APIDOC
## bright_yellow()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightYellow`].

### Method
`bright_yellow()`

### Example
```rust
println!("{}", value.bright_yellow());
```
```

```APIDOC
## bright_blue()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightBlue`].

### Method
`bright_blue()`

### Example
```rust
println!("{}", value.bright_blue());
```
```

```APIDOC
## bright_magenta()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightMagenta`].

### Method
`bright_magenta()`

### Example
```rust
println!("{}", value.bright_magenta());
```
```

```APIDOC
## bright_cyan()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightCyan`].

### Method
`bright_cyan()`

### Example
```rust
println!("{}", value.bright_cyan());
```
```

```APIDOC
## bright_white()

### Description
Returns `self` with the `fg()` set to [`Color :: BrightWhite`].

### Method
`bright_white()`

### Example
```rust
println!("{}", value.bright_white());
```
```

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

### Drop implementation for Mint

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Handles the checking or updating of goldenfiles when the Mint object goes out of scope. This behavior is influenced by the UPDATE_GOLDENFILES environment variable.

```APIDOC
## drop(&mut self)

### Description
Called when the mint goes out of scope to check or update goldenfiles. If the `UPDATE_GOLDENFILES` environment variable is set to "1", goldenfiles will be updated. Otherwise, they will be checked against the current files.

### Behavior
- If `thread::panicking()` is true, this method returns early.
- Checks or updates goldenfiles based on the `UPDATE_GOLDENFILES` environment variable.
```

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

### on_bright

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the `quirk()` set to `Quirk::OnBright`.

```APIDOC
## fn on_bright(&self) -> Painted<&T>

### Description
Returns `self` with the `quirk()` set to [`Quirk :: OnBright`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.on_bright());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### bright

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the `quirk()` set to `Quirk::Bright`.

```APIDOC
## fn bright(&self) -> Painted<&T>

### Description
Returns `self` with the `quirk()` set to [`Quirk :: Bright`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.bright());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Iterator for File Bytes

Source: https://docs.rs/goldenfile/latest/src/goldenfile/differs.rs.html

Creates an iterator that yields bytes from a file. It wraps file opening and reading in a helper function that panics on I/O errors.

```rust
fn file_byte_iter(path: &Path) -> impl Iterator<Item = u8> + '_ {
    BufReader::new(open_file(path))
        .bytes()
        .map(move |b| check_io(b, "reading file", path))
}
```

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

### get_differ_for_path Function Signature

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/fn.get_differ_for_path.html

This is the function signature for get_differ_for_path. It takes a path as input and returns a Differ. The path can be any type that can be referenced as a Path.

```rust
pub fn get_differ_for_path<P: AsRef<Path>>(_path: P) -> Differ
```

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

### wrap

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the `quirk()` set to `Quirk::Wrap`.

```APIDOC
## fn wrap(&self) -> Painted<&T>

### Description
Returns `self` with the `quirk()` set to [`Quirk :: Wrap`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.wrap());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Set Background to Bright Green

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Use this method to set the background color of the painted text to Bright Green. This is a convenience method for setting the background color.

```rust
println!("{}", value.on_bright_green());
```

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

### Set Background to Bright Blue

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Use this method to set the background color of the painted text to Bright Blue. This is a convenience method for setting the background color.

```rust
println!("{}", value.on_bright_blue());
```

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

### Set Background to Bright Magenta

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Use this method to set the background color of the painted text to Bright Magenta. This is a convenience method for setting the background color.

```rust
println!("{}", value.on_bright_magenta());
```

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

### dim

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Returns `self` with the `attr()` set to `Attribute::Dim`.

```APIDOC
## fn dim(&self) -> Painted<&T>

### Description
Returns `self` with the `attr()` set to [`Attribute :: Dim`].

### Method
This is a method call on an existing object.

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
println!("{}", value.dim());
```

### Response
#### Success Response
- `Painted<&T>`: The modified painted object.

#### Response Example
```rust
// Example output depends on the context of 'value'
```
```

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

### Mint Struct Definition

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Defines the Mint struct, which is used to create golden files. Its internal fields are private.

```rust
pub struct Mint {
  /* private fields */
}
```

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

### Register New Goldenpath with Differ

Source: https://docs.rs/goldenfile/latest/goldenfile/mint/struct.Mint.html

Registers a new golden file path with a custom differ. Returns a temporary path that can be written to.

```rust
pub fn new_goldenpath_with_differ<P: AsRef<Path>>(
  &mut self,
  path: P,
  differ: Differ,
) -> Result<PathBuf>
```

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

### Update Golden Files with Environment Variable

Source: https://docs.rs/goldenfile/latest/src/goldenfile/lib.rs.html

To update the checked-in golden file versions, run your tests with the `UPDATE_GOLDENFILES` environment variable set to `1`.

```sh
UPDATE_GOLDENFILES=1 cargo test

```

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

### Register New Goldenfile with Specific Differ

Source: https://docs.rs/goldenfile/latest/src/goldenfile/mint.rs.html

Register a goldenfile with a pre-defined differ strategy. This is useful when the default inference is not suitable. The function returns a path to a temporary file.

```rust
pub fn new_goldenpath_with_differ<P: AsRef<Path>>(
        &mut self,
        path: P,
        differ: Differ,
    ) -> Result<PathBuf> {
        if !path.as_ref().is_relative() {
            return Err(Error::new(
                ErrorKind::InvalidInput,
                "Path must be relative.",
            ));
        }

        let abs_path = self.tempdir.path().to_path_buf().join(path.as_ref());
        self.files.push((path.as_ref().to_path_buf(), differ));

        Ok(abs_path)
    }
```