Bump documentation links

CHANGES.md

@@ -15,6 +15,8 @@ Changes highlights for recent major versions.
 
 * Add read macros: `assert_fs_read_to_string_*`, `assert_io_read_to_string_*`, et al.
 
+* Enable `use assertables::` syntax for each macro by using `$crate::*`.
+
 * Breaking change: migrate from `assert_read_to_string_*`. to `assert_io_read_to_string_*`.
 
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "assertables"
-version = "8.10.0"
+version = "8.10.1"
 authors = ["Joel Parker Henderson <joel@joelparkerhenderson.com>"]
 edition = "2021"
 description = "Assertables: assert macros for better testing, debugging, quality assurance, and runtime reliability."

README.md

@@ -19,102 +19,114 @@ The Rust programming language provides assert macros to test code:
 
 The assertables crate provides many more, so you can write smarter tests.
 
+Examples:
+
+```rust
+use assertables::*;
+assert_approx_eq!(1.0000001, 1.0000002); // compare floating point numbers
+assert_starts_with!("hello world", "hello"); // compare strings and substrings
+assert_set_eq!([1, 2, 3], [3, 2, 1]); // compare set collections order-independently
+assert_fs_read_to_string_eq!("actual.txt", "expect.txt"); // compare file text
+```
+
+## Assert macros
+
 For values:
 
-* [`assert_lt!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_lt.html) `// less than`
-* [`assert_le!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_le.html) `// less than or equal`
-* [`assert_gt!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_gt.html) `// greater than`
-* [`assert_ge!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ge.html) `// greater than or equal`
+* [`assert_lt!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_lt.html) `// less than`
+* [`assert_le!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_le.html) `// less than or equal`
+* [`assert_gt!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_gt.html) `// greater than`
+* [`assert_ge!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ge.html) `// greater than or equal`
 
 For approximation:
 
-* [`assert_approx_eq!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_approx_eq.html)
-* [`assert_approx_ne!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_approx_ne.html)
+* [`assert_approx_eq!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_approx_eq.html)
+* [`assert_approx_ne!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_approx_ne.html)
 
 For strings:
 
-* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_starts_with.html)
-* [`assert_ends_with!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ends_with.html)
+* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_starts_with.html)
+* [`assert_ends_with!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ends_with.html)
 
 For matching:
 
-* [`assert_contains!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_contains.html)
-* [`assert_is_match!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_is_match.html)
+* [`assert_contains!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_contains.html)
+* [`assert_is_match!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_is_match.html)
 
 For infix operators:
 
-* [`assert_infix!(a == b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_infix.html)
-* [`assert_infix!(a && b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_infix.html)
+* [`assert_infix!(a == b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_infix.html)
+* [`assert_infix!(a && b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_infix.html)
 
 For nearness:
 
-* [`assert_in_delta!(a, b, delta)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_in_delta.html)
-* [`assert_in_epsilon!(a, b, epsilon)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_in_epsilon.html)
+* [`assert_in_delta!(a, b, delta)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_in_delta.html)
+* [`assert_in_epsilon!(a, b, epsilon)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_in_epsilon.html)
 
 For Result Ok/Err:
 
-* [`assert_ok!(a)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ok.html)
-* [`assert_ok_eq!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ok_eq.html)
-* [`assert_ok_eq_expr!(a, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ok_eq_expr.html)
-* [`assert_ok_ne!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ok_ne.html)
-* [`assert_ok_ne_expr!(a, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ok_ne_expr.html)
-* [`assert_err!(a)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_err.html)
+* [`assert_ok!(a)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ok.html)
+* [`assert_ok_eq!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ok_eq.html)
+* [`assert_ok_eq_expr!(a, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ok_eq_expr.html)
+* [`assert_ok_ne!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ok_ne.html)
+* [`assert_ok_ne_expr!(a, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ok_ne_expr.html)
+* [`assert_err!(a)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_err.html)
 
 For Option Some/None:
 
-* [`assert_some!(a)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_some.html)
-* [`assert_some_eq!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_some_eq.html)
-* [`assert_some_eq_expr!(a, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_some_eq_expr.html)
-* [`assert_some_ne!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_some_ne.html)
-* [`assert_some_ne_expr!(a, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_some_ne_expr.html)
-* [`assert_none!(a)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_none.html)
+* [`assert_some!(a)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_some.html)
+* [`assert_some_eq!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_some_eq.html)
+* [`assert_some_eq_expr!(a, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_some_eq_expr.html)
+* [`assert_some_ne!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_some_ne.html)
+* [`assert_some_ne_expr!(a, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_some_ne_expr.html)
+* [`assert_none!(a)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_none.html)
 
 For Poll Ready/Pending:
 
-* [`assert_ready!(a)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ready.html)
-* [`assert_ready_eq!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ready_eq.html)
-* [`assert_ready_eq_expr!(a, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ready_eq_expr.html)
-* [`assert_ready_ne!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ready_ne.html)
-* [`assert_ready_ne_expr!(a, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_ready_ne_expr.html)
-* [`assert_pending!(a)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_pending.html)
+* [`assert_ready!(a)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ready.html)
+* [`assert_ready_eq!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ready_eq.html)
+* [`assert_ready_eq_expr!(a, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ready_eq_expr.html)
+* [`assert_ready_ne!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ready_ne.html)
+* [`assert_ready_ne_expr!(a, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_ready_ne_expr.html)
+* [`assert_pending!(a)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_pending.html)
 
 For collections such as arrays, vectors, maps, sets:
 
-* [`assert_set_subset!(collection1, collection2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_set_subset.html)
-* [`assert_set_disjoint!(collection1, collection2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_set_disjoint.html)
+* [`assert_set_subset!(collection1, collection2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_set_subset.html)
+* [`assert_set_disjoint!(collection1, collection2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_set_disjoint.html)
 
 For file system paths and input/output readers:
 
-* [`assert_fs_read_to_string_eq!(path1, path2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_fs_read_to_string_eq.html)
-* [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_io_read_to_string_eq.html)
+* [`assert_fs_read_to_string_eq!(path1, path2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_fs_read_to_string_eq.html)
+* [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_io_read_to_string_eq.html)
 
 For command capture of standard output and standard error:
 
-* [`assert_command_stdout_eq!(command1, command2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_command_stdout_eq.html)
-* [`assert_program_args_stdout_eq!(program1, args1, program2, args2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_program_args_stdout_eq.html)
+* [`assert_command_stdout_eq!(command1, command2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_command_stdout_eq.html)
+* [`assert_program_args_stdout_eq!(program1, args1, program2, args2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_program_args_stdout_eq.html)
 
 There are many more macros that are grouped into modules.
 
 Modules for collections, such as arrays, vectors, lists, maps:
 
-* [`assert_set`](https://docs.rs/assertables/8.9.0/assertables/assert_set) for set collections
-* [`assert_bag`](https://docs.rs/assertables/8.9.0/assertables/assert_bag) for bag collections
+* [`assert_set`](https://docs.rs/assertables/8.10.1/assertables/assert_set) for set collections
+* [`assert_bag`](https://docs.rs/assertables/8.10.1/assertables/assert_bag) for bag collections
 
 Modules for functions:
 
-* [`assert_fn`](https://docs.rs/assertables/8.9.0/assertables/assert_fn) for functions in general.
-* [`assert_fn_ok`](https://docs.rs/assertables/8.9.0/assertables/assert_fn_ok) for functions that return `Result::Ok`.
-* [`assert_fn_err`](https://docs.rs/assertables/8.9.0/assertables/assert_fn_err) for functions that return `Result::Err`.
+* [`assert_fn`](https://docs.rs/assertables/8.10.1/assertables/assert_fn) for functions in general.
+* [`assert_fn_ok`](https://docs.rs/assertables/8.10.1/assertables/assert_fn_ok) for functions that return `Result::Ok`.
+* [`assert_fn_err`](https://docs.rs/assertables/8.10.1/assertables/assert_fn_err) for functions that return `Result::Err`.
 
 Modules for readers:
 
-* [`assert_fs_read_to_string`](https://docs.rs/assertables/8.9.0/assertables/assert_fs_read_to_string) for file system path contents.
-* [`assert_io_read_to_string`](https://docs.rs/assertables/8.9.0/assertables/assert_io_read_to_string) for input/output reader streams.
+* [`assert_fs_read_to_string`](https://docs.rs/assertables/8.10.1/assertables/assert_fs_read_to_string) for file system path contents.
+* [`assert_io_read_to_string`](https://docs.rs/assertables/8.10.1/assertables/assert_io_read_to_string) for input/output reader streams.
 
 Modules for external calls:
 
-* [`assert_command`](https://docs.rs/assertables/8.9.0/assertables/assert_command) for commands with stdout/stderr.
-* [`assert_program_args`](https://docs.rs/assertables/8.9.0/assertables/assert_program_args) for programs with args with stdout/stderr.
+* [`assert_command`](https://docs.rs/assertables/8.10.1/assertables/assert_command) for commands with stdout/stderr.
+* [`assert_program_args`](https://docs.rs/assertables/8.10.1/assertables/assert_program_args) for programs with args with stdout/stderr.
 
 
 ### Top 3 benefits
@@ -148,9 +160,9 @@ All the assert macros have 3 forms for different purposes:
 
 Examples:
 
-* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_starts_with.html) // panic!
-* [`debug_assert_starts_with!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.debug_assert_starts_with.html) // panic! in debug mode
-* [`assert_starts_with_as_result!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_starts_with_as_result.html) // return Ok or Err
+* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_starts_with.html) // panic!
+* [`debug_assert_starts_with!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.debug_assert_starts_with.html) // panic! in debug mode
+* [`assert_starts_with_as_result!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_starts_with_as_result.html) // return Ok or Err
 
 
 ### Forms for messages
@@ -162,8 +174,8 @@ All the assert macros have 2 forms for messages.
 
 Examples:
 
-* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_starts_with.html)
-* [`assert_starts_with!(a, b, "Your custom message here")`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_starts_with.html)
+* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_starts_with.html)
+* [`assert_starts_with!(a, b, "Your custom message here")`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_starts_with.html)
 
 
 ### Forms for other versus expression
@@ -175,15 +187,15 @@ Many of the assert macros have 2 forms for comparing left hand side and right ha
 
 Examples:
 
-* [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_io_read_to_string_eq.html)
-* [`assert_io_read_to_string_eq_expr!(reader, expr)`](https://docs.rs/assertables/8.9.0/assertables/macro.assert_io_read_to_string_eq_expr.html)
+* [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_io_read_to_string_eq.html)
+* [`assert_io_read_to_string_eq_expr!(reader, expr)`](https://docs.rs/assertables/8.10.1/assertables/macro.assert_io_read_to_string_eq_expr.html)
 
 
 ## Tracking
 
 * Package: assertables-rust-crate
-* Version: 8.10.0
+* Version: 8.10.1
 * Created: 2021-03-30T15:47:49Z
-* Updated: 2024-09-27T18:25:43Z
+* Updated: 2024-09-28T09:28:51Z
 * License: MIT or Apache-2.0 or GPL-2.0 or GPL-3.0 or contact us for more
 * Contact: Joel Parker Henderson (joel@sixarm.com)

doc/lib/assert_approx_eq/index.html

@@ -2,7 +2,8 @@
 <p>Pseudocode:<br>
 | a - b | ≤ 1e-6</p>
 <h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
-<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>a: f32 = <span class="number">1.0000001</span>;
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+<span class="kw">let </span>a: f32 = <span class="number">1.0000001</span>;
 <span class="kw">let </span>b: f32 = <span class="number">1.0000011</span>;
 <span class="macro">assert_approx_eq!</span>(a, b);</code></pre></div>
 <h3 id="comparisons"><a class="doc-anchor" href="#comparisons">§</a>Comparisons</h3>

doc/lib/assert_approx_ne/index.html

@@ -2,7 +2,8 @@
 <p>Pseudocode:<br>
 | a - b | &gt; 1e-6</p>
 <h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
-<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>a: f32 = <span class="number">1.0000001</span>;
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+<span class="kw">let </span>a: f32 = <span class="number">1.0000001</span>;
 <span class="kw">let </span>b: f32 = <span class="number">1.0000012</span>;
 <span class="macro">assert_approx_ne!</span>(a, b);</code></pre></div>
 <h3 id="comparisons"><a class="doc-anchor" href="#comparisons">§</a>Comparisons</h3>

doc/lib/assert_bag/assert_bag_eq/index.html

@@ -2,7 +2,8 @@
 <p>Pseudocode:<br>
 (collection1 into bag) = (collection2 into bag)</p>
 <h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
-<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>];
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+<span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>];
 <span class="kw">let </span>b = [<span class="number">1</span>, <span class="number">1</span>];
 <span class="macro">assert_bag_eq!</span>(<span class="kw-2">&amp;</span>a, <span class="kw-2">&amp;</span>b);</code></pre></div>
 <h2 id="module-macros"><a class="doc-anchor" href="#module-macros">§</a>Module macros</h2>

doc/lib/assert_bag/assert_bag_ne/index.html

@@ -2,7 +2,8 @@
 <p>Pseudocode:<br>
 (collection1 into bag) ≠ (collection2 into bag)</p>
 <h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
-<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>];
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+<span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>];
 <span class="kw">let </span>b = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>];
 <span class="macro">assert_bag_ne!</span>(<span class="kw-2">&amp;</span>a, <span class="kw-2">&amp;</span>b);</code></pre></div>
 <p>This implementation uses <a href="https://doc.rust-lang.org/std/collections/struct.BTreeMap.html"><code>std::collections::BTreeMap</code></a> to count items and sort them.</p>

doc/lib/assert_bag/assert_bag_subbag/index.html

@@ -2,7 +2,8 @@
 <p>Pseudocode:<br>
 (collection1 into bag) ⊂ (collection2 into bag)</p>
 <h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
-<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>];
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+<span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>];
 <span class="kw">let </span>b = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>];
 <span class="macro">assert_bag_subbag!</span>(<span class="kw-2">&amp;</span>a, <span class="kw-2">&amp;</span>b);</code></pre></div>
 <p>This implementation uses <a href="https://doc.rust-lang.org/std/collections/struct.BTreeMap.html"><code>std::collections::BTreeMap</code></a> to count items and sort them.</p>

doc/lib/assert_bag/assert_bag_superbag/index.html

@@ -2,7 +2,8 @@
 <p>Pseudocode:<br>
 (collection1 into bag) ⊃ (collection2 into bag)</p>
 <h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
-<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>];
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+<span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>];
 <span class="kw">let </span>b = [<span class="number">1</span>, <span class="number">1</span>];
 <span class="macro">assert_bag_superbag!</span>(<span class="kw-2">&amp;</span>a, <span class="kw-2">&amp;</span>b);</code></pre></div>
 <p>This implementation uses <a href="https://doc.rust-lang.org/std/collections/struct.BTreeMap.html"><code>std::collections::BTreeMap</code></a> to count items and sort them.</p>