fix(deps): update rust crate textwrap to 0.16

[renovate]

This PR contains the following updates:

Package	Type	Update	Change
textwrap	dependencies	minor	0.11 -> 0.16

---

Release Notes

mgeisler/textwrap (textwrap)

v0.16.0

Compare Source

This release marks Options as non_exhaustive and extends it to
make line endings configurable, it adds new fast paths to fill and
wrap, and it fixes crashes in unfill and refill.

• #​480: Mark
  Options as non_exhaustive. This will allow us to extend the
  struct in the future without breaking backwards compatibility.
• #​478: Add fast
  paths to fill and wrap. This makes the functions 10-25 times
  faster when the no wrapping is needed.
• #​468: Fix refill
  to add back correct line ending.
• #​467: Fix crashes
  in unfill and refill.
• #​458: Test with
  Rust 1.56 (first compiler release with support for Rust 2021).
• #​454: Make line
  endings configurable.
• #​448: Migrate to
  the Rust 2021 edition.

v0.15.2

Compare Source

This release is identical to 0.15.0 and is only there to give people a
way to install crates which depend on the yanked 0.15.1 release. See
#​484 for details.

v0.15.1

Compare Source

This release was yanked since it accidentally broke backwards
compatibility with 0.15.0.

v0.15.0

Compare Source

This is a major feature release with two main changes:

• #​421: Use f64
  instead of usize for fragment widths.

  This fixes problems with overflows in the internal computations of
  wrap_optimal_fit when fragments (words) or line lengths had
  extreme values, such as usize::MAX.

• #​438: Simplify
  Options by removing generic type parameters.

  This change removes the new generic parameters introduced in version
  0.14, as well as the original WrapSplitter parameter which has
  been present since very early versions.

  The result is a simplification of function and struct signatures
  across the board. So what used to be

  let options: Options<
      wrap_algorithms::FirstFit,
      word_separators::AsciiSpace,
      word_splitters::HyphenSplitter,
  > = Options::new(80);

  if types are fully written out, is now simply

  let options: Options<'_> = Options::new(80);

  The anonymous lifetime represent the lifetime of the
  initial_indent and subsequent_indent strings. The change is
  nearly performance neutral (a 1-2% regression).

Smaller improvements and changes:

• #​404: Make
  documentation for short last-line penalty more precise.
• #​405: Cleanup and
  simplify Options docstring.
• #​411: Default to
  OptimalFit in interactive example.
• #​415: Add demo
  program to help compute binary sizes.
• #​423: Add fuzz
  tests with fully arbitrary fragments.
• #​424: Change
  wrap_optimal_fit penalties to non-negative numbers.
• #​430: Add
  debug-words example.
• #​432: Use precise
  dependency versions in Cargo.toml.

v0.14.2

Compare Source

The 0.14.1 release included more changes than intended and has been
yanked. The change intended for 0.14.1 is now included in 0.14.2.

v0.14.1

Compare Source

This release fixes a panic reported by @​Makoto, thanks!

• #​391: Fix panic in
  find_words due to string access outside of a character boundary.

v0.14.0

Compare Source

This is a major feature release which makes Textwrap more configurable
and flexible. The high-level API of textwrap::wrap and
textwrap::fill remains unchanged, but low-level structs have moved
around.

The biggest change is the introduction of new generic type parameters
to the Options struct. These parameters lets you statically
configure the wrapping algorithm, the word separator, and the word
splitter. If you previously spelled out the full type for Options,
you now need to take the extra type parameters into account. This
means that

let options: Options<HyphenSplitter> = Options::new(80);

changes to

let options: Options<
    wrap_algorithms::FirstFit,
    word_separators::AsciiSpace,
    word_splitters::HyphenSplitter,
> = Options::new(80);

This is quite a mouthful, so we suggest using type inference where
possible. You won’t see any chance if you call wrap directly with a
width or with an Options value constructed on the fly. Please open
an issue if this causes problems for you!

New WordSeparator Trait

• #​332: Add
  WordSeparator trait to allow customizing how words are found in a
  line of text. Until now, Textwrap would always assume that words are
  separated by ASCII space characters. You can now customize this as
  needed.

• #​313: Add support
  for using the Unicode line breaking algorithm to find words. This is
  done by adding a second implementation of the new WordSeparator
  trait. The implementation uses the unicode-linebreak crate, which is
  a new optional dependency.

  With this, Textwrap can be used with East-Asian languages such as
  Chinese or Japanese where there are no spaces between words.
  Breaking a long sequence of emojis is another example where line
  breaks might be wanted even if there are no whitespace to be found.
  Feedback would be appreciated for this feature.

Indent

• #​353: Trim trailing
  whitespace from prefix in indent.

  Before, empty lines would get no prefix added. Now, empty lines have
  a trimmed prefix added. This little trick makes indent much more
  useful since you can now safely indent with "# " without creating
  trailing whitespace in the output due to the trailing whitespace in
  your prefix.

• #​354: Make indent
  about 20% faster by preallocating the output string.

Documentation

• #​308: Document
  handling of leading and trailing whitespace when wrapping text.

WebAssembly Demo

• #​310: Thanks to
  WebAssembly, you can now try out Textwrap directly in your browser.
  Please try it out: https://mgeisler.github.io/textwrap/.

New Generic Parameters

• #​331: Remove outer
  boxing from Options.

• #​357: Replace
  core::WrapAlgorithm enum with a wrap_algorithms::WrapAlgorithm
  trait. This allows for arbitrary wrapping algorithms to be plugged
  into the library.

• #​358: Switch
  wrapping functions to use a slice for line_widths.

• #​368: Move
  WordSeparator and WordSplitter traits to separate modules.
  Before, Textwrap had several top-level structs such as
  NoHyphenation and HyphenSplitter. These implementations of
  WordSplitter now lives in a dedicated word_splitters module.
  Similarly, we have a new word_separators module for
  implementations of WordSeparator.

• #​369: Rename
  Options::splitter to Options::word_splitter for consistency with
  the other fields backed by traits.

v0.13.4

Compare Source

This release removes println! statements which was left behind in
unfill by mistake.

• #​296: Improve house
  building example with more comments.
• #​297: Remove debug
  prints in the new unfill function.

v0.13.3

Compare Source

This release contains a bugfix for indent and improved handling of
emojis. We’ve also added a new function for formatting text in columns
and functions for reformatting already wrapped text.

• #​276: Extend
  core::display_width to handle emojis when the unicode-width Cargo
  feature is disabled.
• #​279: Make indent
  preserve existing newlines in the input string. Before,
  indent("foo", "") would return "foo\n" by mistake. It now
  returns "foo" instead.
• #​281: Ensure all
  Options fields have examples.
• #​282: Add a
  wrap_columns function.
• #​294: Add new
  unfill and refill functions.

v0.13.2

Compare Source

This release primarily makes all dependencies optional. This makes it
possible to slim down textwrap as needed.

• #​254: impl WordSplitter for Box<T> where T: WordSplitter.
• #​255: Use command
  line arguments as initial text in interactive example.
• #​256: Introduce
  fuzz tests for wrap_optimal_fit and wrap_first_fit.
• #​260: Make the
  unicode-width dependency optional.
• #​261: Make the
  smawk dependency optional.

v0.13.1

Compare Source

This is a bugfix release which fixes a regression in 0.13.0. The bug
meant that colored text was wrapped incorrectly.

• #​245: Support
  deleting a word with Ctrl-Backspace in the interactive demo.
• #​246: Show build
  type (debug/release) in interactive demo.
• #​249: Correctly
  compute width while skipping over ANSI escape sequences.

v0.13.0

Compare Source

This is a major release which rewrites the core logic, adds many new
features, and fixes a couple of bugs. Most programs which use
textwrap stays the same, incompatibilities and upgrade notes are
given below.

Clone the repository and run the following to explore the new features
in an interactive demo (Linux only):

$ cargo run --example interactive --all-features

Bug Fixes

Rewritten core wrapping algorithm

• #​221: Reformulate
  wrapping in terms of words with whitespace and penalties.

The core wrapping algorithm has been completely rewritten. This fixed
bugs and simplified the code, while also making it possible to use
textwrap outside the context of the terminal.

As part of this, trailing whitespace is now discarded consistently
from wrapped lines. Before we would inconsistently remove whitespace
at the end of wrapped lines, except for the last. Leading whitespace
is still preserved.

New Features

Optimal-fit wrapping

• #​234: Introduce
  wrapping using an optimal-fit algorithm.

This release adds support for new wrapping algorithm which finds a
globally optimal set of line breaks, taking certain penalties into
account. As an example, the old algorithm would produce

"To be, or"
"not to be:"
"that is"
"the"
"question"

Notice how the fourth line with “the” is very short. The new algorithm
shortens the previous lines slightly to produce fewer short lines:

"To be,"
"or not to"
"be: that"
"is the"
"question"

Use the new textwrap::core::WrapAlgorithm enum to select between the
new and old algorithm. By default, the new algorithm is used.

The optimal-fit algorithm is inspired by the line breaking algorithm
used in TeX, described in the 1981 article Breaking Paragraphs into
Lines by
Knuth and Plass.

In-place wrapping

• #​226: Add a
  fill_inplace function.

When the text you want to fill is already a temporary String, you
can now mutate it in-place with fill_inplace:

let mut greeting = format!("Greetings {}, welcome to the game! You have {} lives left.",
                           player.name, player.lives);
fill_inplace(&mut greeting, line_width);

This is faster than calling fill and it will reuse the memory
already allocated for the string.

Changed Features

Wrapper is replaced with Options

• #​213: Simplify API
  with only top-level functions.
• #​215: Reintroducing
  the type parameter on Options (previously known as Wrapper).
• #​219: Allow using
  trait objects with fill & wrap.
• #​227: Replace
  WrapOptions with Into<Options>.

The Wrapper struct held the options (line width, indentation, etc)
for wrapping text. It was also the entry point for actually wrapping
the text via its methods such as wrap, wrap_iter,
into_wrap_iter, and fill methods.

The struct has been replaced by a simpler Options struct which only
holds options. The Wrapper methods are gone, their job has been
taken over by the top-level wrap and fill functions. The signature
of these functions have changed from

fn fill(s: &str, width: usize) -> String;

fn wrap(s: &str, width: usize) -> Vec<Cow<'_, str>>;

to the more general

fn fill<'a, S, Opt>(text: &str, options: Opt) -> String
where
    S: WordSplitter,
    Opt: Into<Options<'a, S>>;

fn wrap<'a, S, Opt>(text: &str, options: Opt) -> Vec<Cow<'_, str>>
where
    S: WordSplitter,
    Opt: Into<Options<'a, S>>;

The Into<Options<'a, S> bound allows you to pass an usize (which
is interpreted as the line width) and a full Options object. This
allows the new functions to work like the old, plus you can now fully
customize the behavior of the wrapping via Options when needed.

Code that call textwrap::wrap or textwrap::fill can remain
unchanged. Code that calls into Wrapper::wrap or Wrapper::fill
will need to be update. This is a mechanical change, please see
#​213 for examples.

Thanks to @​CryptJar and @​Koxiat for their support in the PRs above!

Removed Features

• The wrap_iter and into_wrap_iter methods are gone. This means
  that lazy iteration is no longer supported: you always get all
  wrapped lines back as a Vec. This was done to simplify the code
  and to support the optimal-fit algorithm.

  The first-fit algorithm could still be implemented in an incremental
  fashion. Please let us know if this is important to you.

Other Changes

• #​206: Change
  Wrapper.splitter from T: WordSplitter to Box<dyn WordSplitter>.
• #​216: Forbid the
  use of unsafe code.

v0.12.1

Compare Source

This is a bugfix release.

• Fixed [#​176][issue-176]: Mention compile-time wrapping by linking to
  the [textwrap-macros crate].
• Fixed [#​193][issue-193]: Wrapping with break_words(false) was
  broken and would cause extra whitespace to be inserted when words
  were longer than the line width.

v0.12.0

Compare Source

The code has been updated to the [Rust 2018 edition][rust-2018] and
each new release of textwrap will only support the latest stable
version of Rust. Trying to support older Rust versions is a fool's
errand: our dependencies keep releasing new patch versions that
require newer and newer versions of Rust.

The term_size feature has been replaced by terminal_size. The API
is unchanged, it is just the name of the Cargo feature that changed.

The hyphenation feature now only embeds the hyphenation patterns for
US-English. This slims down the dependency.

• Fixed [#​140][issue-140]: Ignore ANSI escape sequences.
• Fixed [#​158][issue-158]: Unintended wrapping when using external splitter.
• Fixed [#​177][issue-177]: Update examples to the 2018 edition.

---

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR has been generated by Mend Renovate. View repository job log here.

[renovate]

⚠ Artifact update problem

Renovate failed to update an artifact related to this branch. You probably do not want to merge this PR as-is.

♻ Renovate will retry this branch, including artifacts, only when one of the following happens:

• any of the package files in this branch needs updating, or
• the branch becomes conflicted, or
• you click the rebase/retry checkbox if found above, or
• you rename this PR's title to start with "rebase!" to trigger it manually

The artifact failure details are included below:

File name: Cargo.lock

Command failed: docker run --rm --name=renovate_a_sidecar --label=renovate_a_child --memory=3584m -v "/tmp/worker/422aaa/8f8135/repos/github/tauri-apps/cargo-mobile2":"/tmp/worker/422aaa/8f8135/repos/github/tauri-apps/cargo-mobile2" -v "/tmp/worker/422aaa/8f8135/cache":"/tmp/worker/422aaa/8f8135/cache" -e GIT_CONFIG_KEY_0 -e GIT_CONFIG_VALUE_0 -e GIT_CONFIG_KEY_1 -e GIT_CONFIG_VALUE_1 -e GIT_CONFIG_KEY_2 -e GIT_CONFIG_VALUE_2 -e GIT_CONFIG_COUNT -e CONTAINERBASE_CACHE_DIR -w "/tmp/worker/422aaa/8f8135/repos/github/tauri-apps/cargo-mobile2" ghcr.io/containerbase/sidecar:9.23.11 bash -l -c "install-tool rust 1.73.0 && cargo update --config net.git-fetch-with-cli=true --manifest-path Cargo.toml --workspace"
    Updating crates.io index
error: failed to select a version for `textwrap`.
    ... required by package `cargo-mobile2 v0.7.0 (/tmp/worker/422aaa/8f8135/repos/github/tauri-apps/cargo-mobile2)`
versions that meet the requirements `^0.16` are: 0.16.0

the package `cargo-mobile2` depends on `textwrap`, with features: `term_size` but `textwrap` does not have these features.


failed to select a version for `textwrap` which could resolve this conflict

[renovate]

Edited/Blocked Notification

Renovate will not automatically rebase this PR, because it does not recognize the last commit author and assumes somebody else may have edited the PR.

You can manually request rebase by checking the rebase/retry box above.

⚠ Warning: custom changes will be lost.