`arg_ripper` is a macro that allows for easy Dependency Injection for the purposes of mocking
internal variables in functions. It contains a single macro, rip that takes in a list of
local bindings (`let` statements) that occur within the annotated function, and generates a new
function with those as arguments instead of local bindings.

# Examples

```rust
#[rip(inner: i32)]
fn my_func() -> i32 {
    let inner = 42;
    inner
}

fn main() {
    assert_eq!(my_func(), 42);
    assert_eq!(ripped_my_func(69), 69);
}
```

The key feature that makes this useful for unit testing is the ability to change the type of
the argument you are ripping. Note the the type hint on line 1 of the example above, in this
case it's the same as the original version of `inner`, but it doesn't have to be. The only
restriction is that the new code must still compile, making things like this possible:

```rust
#[rip(answer: &str)]
fn print_answer() {
    let answer: i32 = 42;
    println!("{answer}");
}

fn main() {
    print_answer();
    ripped_print_answer("Fourty Two");
}
```

[The repository](https://gitlab.com/yocally/arg_ripper) has more in depth examples of how to use this with
[mockall](https://docs.rs/mockall/latest/mockall/) if you're
curious.