diff options
Diffstat (limited to 'vendor/anstream')
| -rw-r--r-- | vendor/anstream/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | vendor/anstream/Cargo.toml | 144 | ||||
| -rw-r--r-- | vendor/anstream/LICENSE-APACHE | 202 | ||||
| -rw-r--r-- | vendor/anstream/LICENSE-MIT | 19 | ||||
| -rw-r--r-- | vendor/anstream/README.md | 34 | ||||
| -rw-r--r-- | vendor/anstream/benches/stream.rs | 82 | ||||
| -rw-r--r-- | vendor/anstream/benches/strip.rs | 102 | ||||
| -rw-r--r-- | vendor/anstream/benches/wincon.rs | 26 | ||||
| -rw-r--r-- | vendor/anstream/src/adapter/mod.rs | 15 | ||||
| -rw-r--r-- | vendor/anstream/src/adapter/strip.rs | 513 | ||||
| -rw-r--r-- | vendor/anstream/src/adapter/wincon.rs | 304 | ||||
| -rw-r--r-- | vendor/anstream/src/auto.rs | 248 | ||||
| -rw-r--r-- | vendor/anstream/src/buffer.rs | 76 | ||||
| -rw-r--r-- | vendor/anstream/src/lib.rs | 79 | ||||
| -rw-r--r-- | vendor/anstream/src/lockable.rs | 48 | ||||
| -rw-r--r-- | vendor/anstream/src/macros.rs | 313 | ||||
| -rw-r--r-- | vendor/anstream/src/raw.rs | 42 | ||||
| -rw-r--r-- | vendor/anstream/src/strip.rs | 196 | ||||
| -rw-r--r-- | vendor/anstream/src/wincon.rs | 154 |
19 files changed, 2598 insertions, 0 deletions
diff --git a/vendor/anstream/.cargo-checksum.json b/vendor/anstream/.cargo-checksum.json new file mode 100644 index 000000000..19bc3d15a --- /dev/null +++ b/vendor/anstream/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"2ebfee2fc8930f7c9c818df7e5805045ea8d5c74fca74d5db4e9b67f5a6aee76","LICENSE-APACHE":"c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08","LICENSE-MIT":"6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6","README.md":"b230c2257d0c7a49b9bd97f2fa73abedcdc055757b5cedd2b0eb1a7a448ff461","benches/stream.rs":"94226af8a048d5db3d6a2e756ed0a1e3ca44a4927a7648ac673d6c3c621cda35","benches/strip.rs":"0569a82722cec5f2bbbf027ab279b7d946f9be7f2a8e698eb992e01c3d33898a","benches/wincon.rs":"680e86933c008b242a3286c5149c33d3c086426eb99fe134b6e79f7578f96663","src/adapter/mod.rs":"baf4237ea0b18df63609e49d93572ca27c2202a4cbec0220adb5a7e815c7d8ed","src/adapter/strip.rs":"010972f96708c56da9bced98287f134ce43a4f6459c22c1697abdc4fd6f82d00","src/adapter/wincon.rs":"9869aa553c253c49bebc0830628225cd294df8e84837b3952529173b06b24b85","src/auto.rs":"e33d010eb949455cacd31b727d26314105538002f5ebef7be56ab62248bfc8c5","src/buffer.rs":"89712eb5c75ccfd4d4d757be394f2631844d7f0227afe0af4f5c3ff1567b750e","src/lib.rs":"02362b01c9c9326191ac1c2466a1255c93ecc24a395742c4b72babcb89c3997a","src/lockable.rs":"09ffb8a7362c0812da9960234be6cf8290814453be94f6476be64e3804d6ce47","src/macros.rs":"9b8e1c5b0639c019fa2a84cc825e52fcd0749af4876a9ecf3a750f68469986aa","src/raw.rs":"7c6395d17e203b6109501f029556e080758a4438c5af0d79fe727f2f999d9bdf","src/strip.rs":"d8469758e9992109b70c8b21b44794eb7341d29034fb0a9bd746c1174e7484f9","src/wincon.rs":"d27007d3b3453dbe18b49cdc088e8aabec2203149cb1f3e7aa4fcee28071d58b"},"package":"342258dd14006105c2b75ab1bd7543a03bdf0cfc94383303ac212a04939dff6f"}
\ No newline at end of file diff --git a/vendor/anstream/Cargo.toml b/vendor/anstream/Cargo.toml new file mode 100644 index 000000000..eb049069c --- /dev/null +++ b/vendor/anstream/Cargo.toml @@ -0,0 +1,144 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +rust-version = "1.64.0" +name = "anstream" +version = "0.2.6" +include = [ + "build.rs", + "src/**/*", + "Cargo.toml", + "LICENSE*", + "README.md", + "benches/**/*", + "examples/**/*", +] +description = "A simple cross platform library for writing colored text to a terminal." +homepage = "https://github.com/rust-cli/anstyle" +readme = "README.md" +keywords = [ + "ansi", + "terminal", + "color", + "strip", + "wincon", +] +categories = ["command-line-interface"] +license = "MIT OR Apache-2.0" +repository = "https://github.com/rust-cli/anstyle.git" + +[package.metadata.docs.rs] +rustdoc-args = [ + "--cfg", + "docsrs", +] +cargo-args = [ + "-Zunstable-options", + "-Zrustdoc-scrape-examples", +] + +[[package.metadata.release.pre-release-replacements]] +file = "CHANGELOG.md" +search = "Unreleased" +replace = "{{version}}" +min = 1 + +[[package.metadata.release.pre-release-replacements]] +file = "CHANGELOG.md" +search = '\.\.\.HEAD' +replace = "...{{tag_name}}" +exactly = 1 + +[[package.metadata.release.pre-release-replacements]] +file = "CHANGELOG.md" +search = "ReleaseDate" +replace = "{{date}}" +min = 1 + +[[package.metadata.release.pre-release-replacements]] +file = "CHANGELOG.md" +search = "<!-- next-header -->" +replace = """ +<!-- next-header --> +## [Unreleased] - ReleaseDate +""" +exactly = 1 + +[[package.metadata.release.pre-release-replacements]] +file = "CHANGELOG.md" +search = "<!-- next-url -->" +replace = """ +<!-- next-url --> +[Unreleased]: https://github.com/rust-cli/anstyle/compare/{{tag_name}}...HEAD""" +exactly = 1 + +[[bench]] +name = "strip" +harness = false + +[[bench]] +name = "wincon" +harness = false + +[[bench]] +name = "stream" +harness = false + +[dependencies.anstyle] +version = "0.3.0" + +[dependencies.anstyle-parse] +version = "0.1.0" + +[dependencies.concolor-override] +version = "1.0.0" +optional = true + +[dependencies.concolor-query] +version = "0.3.1" +optional = true + +[dependencies.is-terminal] +version = "0.4.4" +optional = true + +[dependencies.utf8parse] +version = "0.2.1" + +[dev-dependencies.criterion] +version = "0.4.0" + +[dev-dependencies.owo-colors] +version = "3.5.0" + +[dev-dependencies.proptest] +version = "1.1.0" + +[dev-dependencies.strip-ansi-escapes] +version = "0.1.1" + +[features] +auto = [ + "dep:concolor-query", + "dep:concolor-override", + "dep:is-terminal", +] +default = [ + "auto", + "wincon", +] +wincon = ["dep:anstyle-wincon"] + +[target."cfg(windows)".dependencies.anstyle-wincon] +version = "0.2.0" +optional = true diff --git a/vendor/anstream/LICENSE-APACHE b/vendor/anstream/LICENSE-APACHE new file mode 100644 index 000000000..8f71f43fe --- /dev/null +++ b/vendor/anstream/LICENSE-APACHE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/vendor/anstream/LICENSE-MIT b/vendor/anstream/LICENSE-MIT new file mode 100644 index 000000000..a2d01088b --- /dev/null +++ b/vendor/anstream/LICENSE-MIT @@ -0,0 +1,19 @@ +Copyright (c) Individual contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/anstream/README.md b/vendor/anstream/README.md new file mode 100644 index 000000000..c3d926602 --- /dev/null +++ b/vendor/anstream/README.md @@ -0,0 +1,34 @@ +# anstream + +> A simple cross platform library for writing colored text to a terminal. + +*A portmanteau of "ansi stream"* + +[][Documentation] + +[](https://crates.io/crates/anstream) + +Specialized `stdout` and `stderr` that accept ANSI escape codes and adapt them +based on the terminal's capabilities. + +`anstream::adapter::strip_str` may also be of interest on its own for low +overhead stripping of ANSI escape codes. + +## License + +Licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally +submitted for inclusion in the work by you, as defined in the Apache-2.0 +license, shall be dual licensed as above, without any additional terms or +conditions. + +[Crates.io]: https://crates.io/crates/anstream +[Documentation]: https://docs.rs/anstream diff --git a/vendor/anstream/benches/stream.rs b/vendor/anstream/benches/stream.rs new file mode 100644 index 000000000..55c20b896 --- /dev/null +++ b/vendor/anstream/benches/stream.rs @@ -0,0 +1,82 @@ +use std::io::Write as _; + +use criterion::{black_box, Criterion}; + +fn stream(c: &mut Criterion) { + for (name, content) in [ + ("demo.vte", &include_bytes!("../tests/demo.vte")[..]), + ("rg_help.vte", &include_bytes!("../tests/rg_help.vte")[..]), + ("rg_linus.vte", &include_bytes!("../tests/rg_linus.vte")[..]), + ( + "state_changes", + &b"\x1b]2;X\x1b\\ \x1b[0m \x1bP0@\x1b\\"[..], + ), + ] { + let mut group = c.benchmark_group(name); + group.bench_function("nop", |b| { + b.iter(|| { + let buffer = anstream::Buffer::with_capacity(content.len()); + let mut stream = buffer; + + stream.write_all(content).unwrap(); + + black_box(stream) + }) + }); + group.bench_function("StripStream", |b| { + b.iter(|| { + let buffer = anstream::Buffer::with_capacity(content.len()); + let mut stream = anstream::StripStream::new(buffer); + + stream.write_all(content).unwrap(); + + black_box(stream) + }) + }); + #[cfg(all(windows, feature = "wincon"))] + group.bench_function("WinconStream", |b| { + b.iter(|| { + let buffer = anstream::Buffer::with_capacity(content.len()); + let mut stream = + anstream::WinconStream::new(anstyle_wincon::Console::new(buffer).unwrap()); + + stream.write_all(content).unwrap(); + + black_box(stream) + }) + }); + group.bench_function("AutoStream::always_ansi", |b| { + b.iter(|| { + let buffer = anstream::Buffer::with_capacity(content.len()); + let mut stream = anstream::AutoStream::always_ansi(buffer); + + stream.write_all(content).unwrap(); + + black_box(stream) + }) + }); + group.bench_function("AutoStream::always", |b| { + b.iter(|| { + let buffer = anstream::Buffer::with_capacity(content.len()); + let mut stream = anstream::AutoStream::always(buffer); + + stream.write_all(content).unwrap(); + + black_box(stream) + }) + }); + group.bench_function("AutoStream::never", |b| { + b.iter(|| { + let buffer = anstream::Buffer::with_capacity(content.len()); + let mut stream = anstream::AutoStream::never(buffer); + + stream.write_all(content).unwrap(); + + black_box(stream) + }) + }); + } +} + +criterion::criterion_group!(benches, stream); +criterion::criterion_main!(benches); diff --git a/vendor/anstream/benches/strip.rs b/vendor/anstream/benches/strip.rs new file mode 100644 index 000000000..af204bf96 --- /dev/null +++ b/vendor/anstream/benches/strip.rs @@ -0,0 +1,102 @@ +use criterion::{black_box, Criterion}; + +#[derive(Default)] +struct Strip(String); +impl Strip { + fn with_capacity(capacity: usize) -> Self { + Self(String::with_capacity(capacity)) + } +} +impl anstyle_parse::Perform for Strip { + fn print(&mut self, c: char) { + self.0.push(c); + } + + fn execute(&mut self, byte: u8) { + if byte.is_ascii_whitespace() { + self.0.push(byte as char); + } + } +} + +fn strip(c: &mut Criterion) { + for (name, content) in [ + ("demo.vte", &include_bytes!("../tests/demo.vte")[..]), + ("rg_help.vte", &include_bytes!("../tests/rg_help.vte")[..]), + ("rg_linus.vte", &include_bytes!("../tests/rg_linus.vte")[..]), + ( + "state_changes", + &b"\x1b]2;X\x1b\\ \x1b[0m \x1bP0@\x1b\\"[..], + ), + ] { + // Make sure the comparison is fair + if let Ok(content) = std::str::from_utf8(content) { + let mut stripped = Strip::with_capacity(content.len()); + let mut parser = anstyle_parse::Parser::<anstyle_parse::DefaultCharAccumulator>::new(); + for byte in content.as_bytes() { + parser.advance(&mut stripped, *byte); + } + assert_eq!( + stripped.0, + anstream::adapter::strip_str(content).to_string() + ); + assert_eq!( + stripped.0, + String::from_utf8(anstream::adapter::strip_bytes(content.as_bytes()).into_vec()) + .unwrap() + ); + } + + let mut group = c.benchmark_group(name); + group.bench_function("advance_strip", |b| { + b.iter(|| { + let mut stripped = Strip::with_capacity(content.len()); + let mut parser = + anstyle_parse::Parser::<anstyle_parse::DefaultCharAccumulator>::new(); + + for byte in content { + parser.advance(&mut stripped, *byte); + } + + black_box(stripped.0) + }) + }); + group.bench_function("strip_ansi_escapes", |b| { + b.iter(|| { + let stripped = strip_ansi_escapes::strip(content).unwrap(); + + black_box(stripped) + }) + }); + if let Ok(content) = std::str::from_utf8(content) { + group.bench_function("strip_str", |b| { + b.iter(|| { + let stripped = anstream::adapter::strip_str(content).to_string(); + + black_box(stripped) + }) + }); + group.bench_function("StripStr", |b| { + b.iter(|| { + let mut stripped = String::with_capacity(content.len()); + let mut state = anstream::adapter::StripStr::new(); + for printable in state.strip_next(content) { + stripped.push_str(printable); + } + + black_box(stripped) + }) + }); + } + group.bench_function("strip_bytes", |b| { + b.iter(|| { + let stripped = anstream::adapter::strip_bytes(content).into_vec(); + + black_box(stripped) + }) + }); + } +} + +criterion::criterion_group!(benches, strip); +criterion::criterion_main!(benches); diff --git a/vendor/anstream/benches/wincon.rs b/vendor/anstream/benches/wincon.rs new file mode 100644 index 000000000..54e1f80af --- /dev/null +++ b/vendor/anstream/benches/wincon.rs @@ -0,0 +1,26 @@ +use criterion::{black_box, Criterion}; + +fn wincon(c: &mut Criterion) { + for (name, content) in [ + ("demo.vte", &include_bytes!("../tests/demo.vte")[..]), + ("rg_help.vte", &include_bytes!("../tests/rg_help.vte")[..]), + ("rg_linus.vte", &include_bytes!("../tests/rg_linus.vte")[..]), + ( + "state_changes", + &b"\x1b]2;X\x1b\\ \x1b[0m \x1bP0@\x1b\\"[..], + ), + ] { + let mut group = c.benchmark_group(name); + group.bench_function("wincon_bytes", |b| { + b.iter(|| { + let mut state = anstream::adapter::WinconBytes::new(); + let stripped = state.extract_next(content).collect::<Vec<_>>(); + + black_box(stripped) + }) + }); + } +} + +criterion::criterion_group!(benches, wincon); +criterion::criterion_main!(benches); diff --git a/vendor/anstream/src/adapter/mod.rs b/vendor/anstream/src/adapter/mod.rs new file mode 100644 index 000000000..f266b6805 --- /dev/null +++ b/vendor/anstream/src/adapter/mod.rs @@ -0,0 +1,15 @@ +//! Gracefully degrade styled output + +mod strip; +mod wincon; + +pub use strip::strip_bytes; +pub use strip::strip_str; +pub use strip::StripBytes; +pub use strip::StripBytesIter; +pub use strip::StripStr; +pub use strip::StripStrIter; +pub use strip::StrippedBytes; +pub use strip::StrippedStr; +pub use wincon::WinconBytes; +pub use wincon::WinconBytesIter; diff --git a/vendor/anstream/src/adapter/strip.rs b/vendor/anstream/src/adapter/strip.rs new file mode 100644 index 000000000..5078c5153 --- /dev/null +++ b/vendor/anstream/src/adapter/strip.rs @@ -0,0 +1,513 @@ +use anstyle_parse::state::state_change; +use anstyle_parse::state::Action; +use anstyle_parse::state::State; + +/// Strip ANSI escapes from a `&str`, returning the printable content +/// +/// This can be used to take output from a program that includes escape sequences and write it +/// somewhere that does not easily support them, such as a log file. +/// +/// For non-contiguous data, see [`StripStr`]. +/// +/// # Example +/// +/// ```rust +/// use std::io::Write as _; +/// +/// let styled_text = "\x1b[32mfoo\x1b[m bar"; +/// let plain_str = anstream::adapter::strip_str(&styled_text).to_string(); +/// assert_eq!(plain_str, "foo bar"); +/// ``` +#[inline] +pub fn strip_str(data: &str) -> StrippedStr<'_> { + StrippedStr::new(data) +} + +/// See [`strip_str`] +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct StrippedStr<'s> { + bytes: &'s [u8], + state: State, +} + +impl<'s> StrippedStr<'s> { + #[inline] + fn new(data: &'s str) -> Self { + Self { + bytes: data.as_bytes(), + state: State::Ground, + } + } + + /// Create a [`String`] of the printable content + #[inline] + #[allow(clippy::inherent_to_string_shadow_display)] // Single-allocation implementation + pub fn to_string(&self) -> String { + use std::fmt::Write as _; + let mut stripped = String::with_capacity(self.bytes.len()); + let _ = write!(&mut stripped, "{}", self); + stripped + } +} + +impl<'s> std::fmt::Display for StrippedStr<'s> { + /// **Note:** this does *not* exhaust the [`Iterator`] + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let iter = Self { + bytes: self.bytes, + state: self.state, + }; + for printable in iter { + printable.fmt(f)?; + } + Ok(()) + } +} + +impl<'s> Iterator for StrippedStr<'s> { + type Item = &'s str; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + next_str(&mut self.bytes, &mut self.state) + } +} + +/// Incrementally strip non-contiguous data +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct StripStr { + state: State, +} + +impl StripStr { + /// Initial state + pub fn new() -> Self { + Default::default() + } + + /// Strip the next segment of data + pub fn strip_next<'s>(&'s mut self, data: &'s str) -> StripStrIter<'s> { + StripStrIter { + bytes: data.as_bytes(), + state: &mut self.state, + } + } +} + +/// See [`StripStr`] +#[derive(Debug, PartialEq, Eq)] +pub struct StripStrIter<'s> { + bytes: &'s [u8], + state: &'s mut State, +} + +impl<'s> Iterator for StripStrIter<'s> { + type Item = &'s str; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + next_str(&mut self.bytes, self.state) + } +} + +#[inline] +fn next_str<'s>(bytes: &mut &'s [u8], state: &mut State) -> Option<&'s str> { + let offset = bytes.iter().copied().position(|b| { + let (next_state, action) = state_change(*state, b); + if next_state != State::Anywhere { + *state = next_state; + } + is_printable_str(action, b) + }); + let (_, next) = bytes.split_at(offset.unwrap_or(bytes.len())); + *bytes = next; + *state = State::Ground; + + let offset = bytes.iter().copied().position(|b| { + let (_next_state, action) = state_change(State::Ground, b); + !is_printable_str(action, b) + }); + let (printable, next) = bytes.split_at(offset.unwrap_or(bytes.len())); + *bytes = next; + if printable.is_empty() { + None + } else { + let printable = unsafe { + from_utf8_unchecked( + printable, + "`bytes` was validated as UTF-8, the parser preserves UTF-8 continuations", + ) + }; + Some(printable) + } +} + +#[inline] +unsafe fn from_utf8_unchecked<'b>(bytes: &'b [u8], safety_justification: &'static str) -> &'b str { + if cfg!(debug_assertions) { + // Catch problems more quickly when testing + std::str::from_utf8(bytes).expect(safety_justification) + } else { + std::str::from_utf8_unchecked(bytes) + } +} + +#[inline] +fn is_printable_str(action: Action, byte: u8) -> bool { + // VT320 considered 0x7f to be `Print`able but we expect to be working in UTF-8 systems and not + // ISO Latin-1, making it DEL and non-printable + const DEL: u8 = 0x7f; + (action == Action::Print && byte != DEL) + || action == Action::BeginUtf8 + // since we know the input is valid UTF-8, the only thing we can do with + // continuations is to print them + || is_utf8_continuation(byte) + || (action == Action::Execute && byte.is_ascii_whitespace()) +} + +#[inline] +fn is_utf8_continuation(b: u8) -> bool { + matches!(b, 0x80..=0xbf) +} + +/// Strip ANSI escapes from bytes, returning the printable content +/// +/// This can be used to take output from a program that includes escape sequences and write it +/// somewhere that does not easily support them, such as a log file. +/// +/// # Example +/// +/// ```rust +/// use std::io::Write as _; +/// +/// let styled_text = "\x1b[32mfoo\x1b[m bar"; +/// let plain_str = anstream::adapter::strip_bytes(styled_text.as_bytes()).into_vec(); +/// assert_eq!(plain_str.as_slice(), &b"foo bar"[..]); +/// ``` +#[inline] +pub fn strip_bytes(data: &[u8]) -> StrippedBytes<'_> { + StrippedBytes::new(data) +} + +/// See [`strip_bytes`] +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct StrippedBytes<'s> { + bytes: &'s [u8], + state: State, + utf8parser: Utf8Parser, +} + +impl<'s> StrippedBytes<'s> { + /// See [`strip_bytes`] + #[inline] + pub fn new(bytes: &'s [u8]) -> Self { + Self { + bytes, + state: State::Ground, + utf8parser: Default::default(), + } + } + + /// Strip the next slice of bytes + /// + /// Used when the content is in several non-contiguous slices + /// + /// # Panic + /// + /// May panic if it is not exhausted / empty + #[inline] + pub fn extend(&mut self, bytes: &'s [u8]) { + debug_assert!( + self.is_empty(), + "current bytes must be processed to ensure we end at the right state" + ); + self.bytes = bytes; + } + + /// Report the bytes has been exhausted + #[inline] + pub fn is_empty(&self) -> bool { + self.bytes.is_empty() + } + + /// Create a [`Vec`] of the printable content + #[inline] + pub fn into_vec(self) -> Vec<u8> { + let mut stripped = Vec::with_capacity(self.bytes.len()); + for printable in self { + stripped.extend(printable); + } + stripped + } +} + +impl<'s> Iterator for StrippedBytes<'s> { + type Item = &'s [u8]; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + next_bytes(&mut self.bytes, &mut self.state, &mut self.utf8parser) + } +} + +/// Incrementally strip non-contiguous data +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct StripBytes { + state: State, + utf8parser: Utf8Parser, +} + +impl StripBytes { + /// Initial state + pub fn new() -> Self { + Default::default() + } + + /// Strip the next segment of data + pub fn strip_next<'s>(&'s mut self, bytes: &'s [u8]) -> StripBytesIter<'s> { + StripBytesIter { + bytes, + state: &mut self.state, + utf8parser: &mut self.utf8parser, + } + } +} + +/// See [`StripBytes`] +#[derive(Debug, PartialEq, Eq)] +pub struct StripBytesIter<'s> { + bytes: &'s [u8], + state: &'s mut State, + utf8parser: &'s mut Utf8Parser, +} + +impl<'s> Iterator for StripBytesIter<'s> { + type Item = &'s [u8]; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + next_bytes(&mut self.bytes, self.state, self.utf8parser) + } +} + +#[inline] +fn next_bytes<'s>( + bytes: &mut &'s [u8], + state: &mut State, + utf8parser: &mut Utf8Parser, +) -> Option<&'s [u8]> { + let offset = bytes.iter().copied().position(|b| { + if *state == State::Utf8 { + true + } else { + let (next_state, action) = state_change(*state, b); + if next_state != State::Anywhere { + *state = next_state; + } + is_printable_bytes(action, b) + } + }); + let (_, next) = bytes.split_at(offset.unwrap_or(bytes.len())); + *bytes = next; + + let offset = bytes.iter().copied().position(|b| { + if *state == State::Utf8 { + if utf8parser.add(b) { + *state = State::Ground; + } + false + } else { + let (next_state, action) = state_change(State::Ground, b); + if next_state != State::Anywhere { + *state = next_state; + } + if *state == State::Utf8 { + utf8parser.add(b); + false + } else { + !is_printable_bytes(action, b) + } + } + }); + let (printable, next) = bytes.split_at(offset.unwrap_or(bytes.len())); + *bytes = next; + if printable.is_empty() { + None + } else { + Some(printable) + } +} + +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct Utf8Parser { + utf8_parser: utf8parse::Parser, +} + +impl Utf8Parser { + fn add(&mut self, byte: u8) -> bool { + let mut b = false; + let mut receiver = VtUtf8Receiver(&mut b); + self.utf8_parser.advance(&mut receiver, byte); + b + } +} + +struct VtUtf8Receiver<'a>(&'a mut bool); + +impl<'a> utf8parse::Receiver for VtUtf8Receiver<'a> { + fn codepoint(&mut self, _: char) { + *self.0 = true; + } + + fn invalid_sequence(&mut self) { + *self.0 = true; + } +} + +#[inline] +fn is_printable_bytes(action: Action, byte: u8) -> bool { + // VT320 considered 0x7f to be `Print`able but we expect to be working in UTF-8 systems and not + // ISO Latin-1, making it DEL and non-printable + const DEL: u8 = 0x7f; + + // Continuations aren't included as they may also be control codes, requiring more context + (action == Action::Print && byte != DEL) + || action == Action::BeginUtf8 + || (action == Action::Execute && byte.is_ascii_whitespace()) +} + +#[cfg(test)] +mod test { + use super::*; + use proptest::prelude::*; + + /// Model based off full parser + fn parser_strip(bytes: &[u8]) -> String { + #[derive(Default)] + struct Strip(String); + impl Strip { + fn with_capacity(capacity: usize) -> Self { + Self(String::with_capacity(capacity)) + } + } + impl anstyle_parse::Perform for Strip { + fn print(&mut self, c: char) { + self.0.push(c); + } + + fn execute(&mut self, byte: u8) { + if byte.is_ascii_whitespace() { + self.0.push(byte as char); + } + } + } + + let mut stripped = Strip::with_capacity(bytes.len()); + let mut parser = anstyle_parse::Parser::<anstyle_parse::DefaultCharAccumulator>::new(); + for byte in bytes { + parser.advance(&mut stripped, *byte); + } + stripped.0 + } + + /// Model verifying incremental parsing + fn strip_char(mut s: &str) -> String { + let mut result = String::new(); + let mut state = StripStr::new(); + while !s.is_empty() { + let mut indices = s.char_indices(); + indices.next(); // current + let offset = indices.next().map(|(i, _)| i).unwrap_or_else(|| s.len()); + let (current, remainder) = s.split_at(offset); + for printable in state.strip_next(current) { + result.push_str(printable); + } + s = remainder; + } + result + } + + /// Model verifying incremental parsing + fn strip_byte(s: &[u8]) -> Vec<u8> { + let mut result = Vec::new(); + let mut state = StripBytes::default(); + for start in 0..s.len() { + let current = &s[start..=start]; + for printable in state.strip_next(current) { + result.extend(printable); + } + } + result + } + + #[test] + fn test_strip_bytes_multibyte() { + let bytes = [240, 145, 141, 139]; + let expected = parser_strip(&bytes); + let actual = String::from_utf8(strip_bytes(&bytes).into_vec()).unwrap(); + assert_eq!(expected, actual); + } + + #[test] + fn test_strip_byte_multibyte() { + let bytes = [240, 145, 141, 139]; + let expected = parser_strip(&bytes); + let actual = String::from_utf8(strip_byte(&bytes).to_vec()).unwrap(); + assert_eq!(expected, actual); + } + + #[test] + fn test_strip_str_del() { + let input = std::str::from_utf8(&[0x7f]).unwrap(); + let expected = ""; + let actual = strip_str(input).to_string(); + assert_eq!(expected, actual); + } + + #[test] + fn test_strip_byte_del() { + let bytes = [0x7f]; + let expected = ""; + let actual = String::from_utf8(strip_byte(&bytes).to_vec()).unwrap(); + assert_eq!(expected, actual); + } + + proptest! { + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn strip_str_no_escapes(s in "\\PC*") { + let expected = parser_strip(s.as_bytes()); + let actual = strip_str(&s).to_string(); + assert_eq!(expected, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn strip_char_no_escapes(s in "\\PC*") { + let expected = parser_strip(s.as_bytes()); + let actual = strip_char(&s); + assert_eq!(expected, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn strip_bytes_no_escapes(s in "\\PC*") { + dbg!(&s); + dbg!(s.as_bytes()); + let expected = parser_strip(s.as_bytes()); + let actual = String::from_utf8(strip_bytes(s.as_bytes()).into_vec()).unwrap(); + assert_eq!(expected, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn strip_byte_no_escapes(s in "\\PC*") { + dbg!(&s); + dbg!(s.as_bytes()); + let expected = parser_strip(s.as_bytes()); + let actual = String::from_utf8(strip_byte(s.as_bytes()).to_vec()).unwrap(); + assert_eq!(expected, actual); + } + } +} diff --git a/vendor/anstream/src/adapter/wincon.rs b/vendor/anstream/src/adapter/wincon.rs new file mode 100644 index 000000000..71edc4cf5 --- /dev/null +++ b/vendor/anstream/src/adapter/wincon.rs @@ -0,0 +1,304 @@ +/// Incrementally convert to wincon calls for non-contiguous data +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct WinconBytes { + parser: anstyle_parse::Parser, + capture: WinconCapture, +} + +impl WinconBytes { + /// Initial state + pub fn new() -> Self { + Default::default() + } + + /// Strip the next segment of data + pub fn extract_next<'s>(&'s mut self, bytes: &'s [u8]) -> WinconBytesIter<'s> { + self.capture.reset(); + self.capture.printable.reserve(bytes.len()); + WinconBytesIter { + bytes, + parser: &mut self.parser, + capture: &mut self.capture, + } + } +} + +/// See [`WinconBytes`] +#[derive(Debug, PartialEq, Eq)] +pub struct WinconBytesIter<'s> { + bytes: &'s [u8], + parser: &'s mut anstyle_parse::Parser, + capture: &'s mut WinconCapture, +} + +impl<'s> Iterator for WinconBytesIter<'s> { + type Item = (anstyle::Style, String); + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + next_bytes(&mut self.bytes, self.parser, self.capture) + } +} + +#[inline] +fn next_bytes( + bytes: &mut &[u8], + parser: &mut anstyle_parse::Parser, + capture: &mut WinconCapture, +) -> Option<(anstyle::Style, String)> { + capture.reset(); + while capture.ready.is_none() { + let byte = if let Some((byte, remainder)) = (*bytes).split_first() { + *bytes = remainder; + *byte + } else { + break; + }; + parser.advance(capture, byte); + } + if capture.printable.is_empty() { + return None; + } + + let style = capture.ready.unwrap_or(capture.style); + Some((style, std::mem::take(&mut capture.printable))) +} + +#[derive(Default, Clone, Debug, PartialEq, Eq)] +struct WinconCapture { + style: anstyle::Style, + printable: String, + ready: Option<anstyle::Style>, +} + +impl WinconCapture { + fn reset(&mut self) { + self.ready = None; + } +} + +impl anstyle_parse::Perform for WinconCapture { + /// Draw a character to the screen and update states. + fn print(&mut self, c: char) { + self.printable.push(c); + } + + /// Execute a C0 or C1 control function. + fn execute(&mut self, byte: u8) { + if byte.is_ascii_whitespace() { + self.printable.push(byte as char); + } + } + + fn csi_dispatch( + &mut self, + params: &anstyle_parse::Params, + _intermediates: &[u8], + ignore: bool, + action: u8, + ) { + if ignore { + return; + } + if action != b'm' { + return; + } + + let mut style = self.style; + for param in params { + let mut state = State::Normal; + let mut r = None; + let mut g = None; + let mut is_bg = false; + for value in param { + match (state, *value) { + (State::Normal, 0) => { + style = anstyle::Style::default(); + break; + } + (State::Normal, 1) => { + style = style.bold(); + break; + } + (State::Normal, 4) => { + style = style.underline(); + break; + } + (State::Normal, 30..=37) => { + let color = to_ansi_color(value - 30).unwrap(); + style = style.fg_color(Some(color.into())); + break; + } + (State::Normal, 38) => { + is_bg = false; + state = State::PrepareCustomColor; + } + (State::Normal, 39) => { + style = style.fg_color(None); + break; + } + (State::Normal, 40..=47) => { + let color = to_ansi_color(value - 40).unwrap(); + style = style.bg_color(Some(color.into())); + break; + } + (State::Normal, 48) => { + is_bg = true; + state = State::PrepareCustomColor; + } + (State::Normal, 49) => { + style = style.bg_color(None); + break; + } + (State::Normal, 90..=97) => { + let color = to_ansi_color(value - 90).unwrap().bright(true); + style = style.fg_color(Some(color.into())); + break; + } + (State::Normal, 100..=107) => { + let color = to_ansi_color(value - 100).unwrap().bright(true); + style = style.bg_color(Some(color.into())); + break; + } + (State::PrepareCustomColor, 5) => { + state = State::Ansi256; + } + (State::PrepareCustomColor, 2) => { + state = State::Rgb; + r = None; + g = None; + } + (State::Ansi256, n) => { + let color = anstyle::Ansi256Color(n as u8); + if is_bg { + style = style.bg_color(Some(color.into())); + } else { + style = style.fg_color(Some(color.into())); + } + break; + } + (State::Rgb, b) => match (r, g) { + (None, _) => { + r = Some(b); + } + (Some(_), None) => { + g = Some(b); + } + (Some(r), Some(g)) => { + let color = anstyle::RgbColor(r as u8, g as u8, b as u8); + if is_bg { + style = style.bg_color(Some(color.into())); + } else { + style = style.fg_color(Some(color.into())); + } + break; + } + }, + _ => { + break; + } + } + } + } + + if style != self.style && !self.printable.is_empty() { + self.ready = Some(self.style); + } + self.style = style; + } +} + +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +enum State { + Normal, + PrepareCustomColor, + Ansi256, + Rgb, +} + +fn to_ansi_color(digit: u16) -> Option<anstyle::AnsiColor> { + match digit { + 0 => Some(anstyle::AnsiColor::Black), + 1 => Some(anstyle::AnsiColor::Red), + 2 => Some(anstyle::AnsiColor::Green), + 3 => Some(anstyle::AnsiColor::Yellow), + 4 => Some(anstyle::AnsiColor::Blue), + 5 => Some(anstyle::AnsiColor::Magenta), + 6 => Some(anstyle::AnsiColor::Cyan), + 7 => Some(anstyle::AnsiColor::White), + _ => None, + } +} + +#[cfg(test)] +mod test { + use super::*; + use owo_colors::OwoColorize as _; + use proptest::prelude::*; + + #[track_caller] + fn verify(input: &str, expected: Vec<(anstyle::Style, &str)>) { + let expected = expected + .into_iter() + .map(|(style, value)| (style, value.to_owned())) + .collect::<Vec<_>>(); + let mut state = WinconBytes::new(); + let actual = state.extract_next(input.as_bytes()).collect::<Vec<_>>(); + assert_eq!(expected, actual); + } + + #[test] + fn start() { + let input = format!("{} world!", "Hello".green().on_red()); + let expected = vec![ + ( + anstyle::AnsiColor::Green.on(anstyle::AnsiColor::Red), + "Hello", + ), + (anstyle::Style::default(), " world!"), + ]; + verify(&input, expected); + } + + #[test] + fn middle() { + let input = format!("Hello {}!", "world".green().on_red()); + let expected = vec![ + (anstyle::Style::default(), "Hello "), + ( + anstyle::AnsiColor::Green.on(anstyle::AnsiColor::Red), + "world", + ), + (anstyle::Style::default(), "!"), + ]; + verify(&input, expected); + } + + #[test] + fn end() { + let input = format!("Hello {}", "world!".green().on_red()); + let expected = vec![ + (anstyle::Style::default(), "Hello "), + ( + anstyle::AnsiColor::Green.on(anstyle::AnsiColor::Red), + "world!", + ), + ]; + verify(&input, expected); + } + + proptest! { + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn wincon_no_escapes(s in "\\PC*") { + let expected = if s.is_empty() { + vec![] + } else { + vec![(anstyle::Style::default(), s.clone())] + }; + let mut state = WinconBytes::new(); + let actual = state.extract_next(s.as_bytes()).collect::<Vec<_>>(); + assert_eq!(expected, actual); + } + } +} diff --git a/vendor/anstream/src/auto.rs b/vendor/anstream/src/auto.rs new file mode 100644 index 000000000..c2317460d --- /dev/null +++ b/vendor/anstream/src/auto.rs @@ -0,0 +1,248 @@ +#[cfg(feature = "auto")] +use crate::ColorChoice; +use crate::Lockable; +use crate::RawStream; +use crate::StripStream; +#[cfg(all(windows, feature = "wincon"))] +use crate::WinconStream; + +/// [`std::io::Write`] that adapts ANSI escape codes to the underlying `Write`s capabilities +#[derive(Debug)] +pub struct AutoStream<S: RawStream> { + inner: StreamInner<S>, +} + +#[derive(Debug)] +enum StreamInner<S: RawStream> { + PassThrough(S), + Strip(StripStream<S>), + #[cfg(all(windows, feature = "wincon"))] + Wincon(WinconStream<S>), +} + +impl<S> AutoStream<S> +where + S: RawStream, +{ + /// Runtime control over styling behavior + #[cfg(feature = "auto")] + #[inline] + pub fn new(raw: S, choice: ColorChoice) -> Self { + match choice { + ColorChoice::Auto => Self::auto(raw), + ColorChoice::AlwaysAnsi => Self::always_ansi(raw), + ColorChoice::Always => Self::always(raw), + ColorChoice::Never => Self::never(raw), + } + } + + /// Auto-adapt for the stream's capabilities + #[cfg(feature = "auto")] + #[inline] + pub fn auto(raw: S) -> Self { + let choice = Self::choice(&raw); + debug_assert_ne!(choice, ColorChoice::Auto); + Self::new(raw, choice) + } + + /// Report the desired choice for the given stream + #[cfg(feature = "auto")] + pub fn choice(raw: &S) -> ColorChoice { + choice(raw) + } + + /// Force ANSI escape codes to be passed through as-is, no matter what the inner `Write` + /// supports. + #[inline] + pub fn always_ansi(raw: S) -> Self { + #[cfg(feature = "auto")] + { + if raw.is_terminal() { + let _ = concolor_query::windows::enable_ansi_colors(); + } + } + Self::always_ansi_(raw) + } + + #[inline] + fn always_ansi_(raw: S) -> Self { + let inner = StreamInner::PassThrough(raw); + AutoStream { inner } + } + + /// Force color, no matter what the inner `Write` supports. + #[inline] + pub fn always(raw: S) -> Self { + if cfg!(windows) { + #[cfg(feature = "auto")] + let use_wincon = raw.is_terminal() + && !concolor_query::windows::enable_ansi_colors().unwrap_or(true) + && !concolor_query::term_supports_ansi_color(); + #[cfg(not(feature = "auto"))] + let use_wincon = true; + if use_wincon { + Self::wincon(raw).unwrap_or_else(|raw| Self::always_ansi_(raw)) + } else { + Self::always_ansi_(raw) + } + } else { + Self::always_ansi(raw) + } + } + + /// Only pass printable data to the inner `Write`. + #[inline] + pub fn never(raw: S) -> Self { + let inner = StreamInner::Strip(StripStream::new(raw)); + AutoStream { inner } + } + + #[inline] + fn wincon(raw: S) -> Result<Self, S> { + #[cfg(all(windows, feature = "wincon"))] + { + let console = anstyle_wincon::Console::new(raw)?; + Ok(Self { + inner: StreamInner::Wincon(WinconStream::new(console)), + }) + } + #[cfg(not(all(windows, feature = "wincon")))] + { + Err(raw) + } + } + + /// Get the wrapped [`RawStream`] + #[inline] + pub fn into_inner(self) -> S { + match self.inner { + StreamInner::PassThrough(w) => w, + StreamInner::Strip(w) => w.into_inner(), + #[cfg(all(windows, feature = "wincon"))] + StreamInner::Wincon(w) => w.into_inner().into_inner(), + } + } + + #[inline] + #[cfg(feature = "auto")] + pub fn is_terminal(&self) -> bool { + match &self.inner { + StreamInner::PassThrough(w) => w.is_terminal(), + StreamInner::Strip(w) => w.is_terminal(), + #[cfg(all(windows, feature = "wincon"))] + StreamInner::Wincon(w) => true, + } + } +} + +#[cfg(feature = "auto")] +fn choice(raw: &dyn RawStream) -> ColorChoice { + let choice = concolor_override::get(); + match choice { + ColorChoice::Auto => { + let clicolor = concolor_query::clicolor(); + let clicolor_enabled = clicolor.unwrap_or(false); + let clicolor_disabled = !clicolor.unwrap_or(true); + if raw.is_terminal() + && !concolor_query::no_color() + && !clicolor_disabled + && (concolor_query::term_supports_color() + || clicolor_enabled + || concolor_query::is_ci()) + || concolor_query::clicolor_force() + { + ColorChoice::Always + } else { + ColorChoice::Never + } + } + ColorChoice::AlwaysAnsi | ColorChoice::Always | ColorChoice::Never => choice, + } +} + +#[cfg(feature = "auto")] +impl<S> is_terminal::IsTerminal for AutoStream<S> +where + S: RawStream, +{ + #[inline] + fn is_terminal(&self) -> bool { + self.is_terminal() + } +} + +impl<S> AutoStream<S> +where + S: Lockable + RawStream, + <S as Lockable>::Locked: RawStream, +{ + /// Get exclusive access to the `AutoStream` + /// + /// Why? + /// - Faster performance when writing in a loop + /// - Avoid other threads interleaving output with the current thread + #[inline] + pub fn lock(self) -> <Self as Lockable>::Locked { + let inner = match self.inner { + StreamInner::PassThrough(w) => StreamInner::PassThrough(w.lock()), + StreamInner::Strip(w) => StreamInner::Strip(w.lock()), + #[cfg(all(windows, feature = "wincon"))] + StreamInner::Wincon(w) => StreamInner::Wincon(w.lock()), + }; + AutoStream { inner } + } +} + +impl<S> std::io::Write for AutoStream<S> +where + S: RawStream, +{ + #[inline] + fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> { + match &mut self.inner { + StreamInner::PassThrough(w) => w.write(buf), + StreamInner::Strip(w) => w.write(buf), + #[cfg(all(windows, feature = "wincon"))] + StreamInner::Wincon(w) => w.write(buf), + } + } + + #[inline] + fn flush(&mut self) -> std::io::Result<()> { + match &mut self.inner { + StreamInner::PassThrough(w) => w.flush(), + StreamInner::Strip(w) => w.flush(), + #[cfg(all(windows, feature = "wincon"))] + StreamInner::Wincon(w) => w.flush(), + } + } + + // Provide explicit implementations of trait methods + // - To reduce bookkeeping + // - Avoid acquiring / releasing locks in a loop + + #[inline] + fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> { + match &mut self.inner { + StreamInner::PassThrough(w) => w.write_all(buf), + StreamInner::Strip(w) => w.write_all(buf), + #[cfg(all(windows, feature = "wincon"))] + StreamInner::Wincon(w) => w.write_all(buf), + } + } + + // Not bothering with `write_fmt` as it just calls `write_all` +} + +impl<S> Lockable for AutoStream<S> +where + S: Lockable + RawStream, + <S as Lockable>::Locked: RawStream, +{ + type Locked = AutoStream<<S as Lockable>::Locked>; + + #[inline] + fn lock(self) -> Self::Locked { + self.lock() + } +} diff --git a/vendor/anstream/src/buffer.rs b/vendor/anstream/src/buffer.rs new file mode 100644 index 000000000..1ba0bffdb --- /dev/null +++ b/vendor/anstream/src/buffer.rs @@ -0,0 +1,76 @@ +/// In-memory [`RawStream`][crate::RawStream] +#[derive(Clone, Default, Debug, PartialEq, Eq)] +pub struct Buffer(Vec<u8>); + +impl Buffer { + #[inline] + pub fn new() -> Self { + Default::default() + } + + #[inline] + pub fn with_capacity(capacity: usize) -> Self { + Self(Vec::with_capacity(capacity)) + } + + #[inline] + pub fn as_bytes(&self) -> &[u8] { + &self.0 + } +} + +impl AsRef<[u8]> for Buffer { + #[inline] + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +#[cfg(feature = "auto")] +impl is_terminal::IsTerminal for Buffer { + #[inline] + fn is_terminal(&self) -> bool { + false + } +} + +impl std::io::Write for Buffer { + #[inline] + fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> { + self.0.extend(buf); + Ok(buf.len()) + } + + #[inline] + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +#[cfg(all(windows, feature = "wincon"))] +impl anstyle_wincon::WinconStream for Buffer { + fn set_colors( + &mut self, + fg: Option<anstyle::AnsiColor>, + bg: Option<anstyle::AnsiColor>, + ) -> std::io::Result<()> { + use std::io::Write as _; + + if let Some(fg) = fg { + write!(self, "{}", fg.render_fg())?; + } + if let Some(bg) = bg { + write!(self, "{}", bg.render_bg())?; + } + if fg.is_none() && bg.is_none() { + write!(self, "{}", anstyle::Reset.render())?; + } + Ok(()) + } + + fn get_colors( + &self, + ) -> std::io::Result<(Option<anstyle::AnsiColor>, Option<anstyle::AnsiColor>)> { + Ok((None, None)) + } +} diff --git a/vendor/anstream/src/lib.rs b/vendor/anstream/src/lib.rs new file mode 100644 index 000000000..1600e8e06 --- /dev/null +++ b/vendor/anstream/src/lib.rs @@ -0,0 +1,79 @@ +//! **Auto-adapting [`stdout`] / [`stderr`] streams** +//! +//! *A portmanteau of "ansi stream"* +//! +//! [`AutoStream`] always accepts [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code), +//! adapting to the user's terminal's capabilities. +//! +//! Benefits +//! - Allows the caller to not be concerned with the terminal's capabilities +//! - Semver safe way of passing styled text between crates as ANSI escape codes offer more +//! compatibility than most crate APIs. +//! +//! # Example +//! +//! ``` +//! # #[cfg(feature = "auto")] { +//! use anstream::println; +//! use owo_colors::OwoColorize as _; +//! +//! // Foreground colors +//! println!("My number is {:#x}!", 10.green()); +//! // Background colors +//! println!("My number is not {}!", 4.on_red()); +//! # } +//! ``` +//! +//! And this will correctly handle piping to a file, etc + +#![cfg_attr(docsrs, feature(doc_auto_cfg))] + +pub mod adapter; +mod buffer; +#[macro_use] +mod macros; +mod auto; +mod lockable; +mod raw; +mod strip; +#[cfg(all(windows, feature = "wincon"))] +mod wincon; + +pub use auto::AutoStream; +pub use lockable::Lockable; +pub use raw::RawStream; +pub use strip::StripStream; +#[cfg(all(windows, feature = "wincon"))] +pub use wincon::WinconStream; + +pub use buffer::Buffer; + +/// Create an ANSI escape code compatible stdout +/// +/// **Note:** Call [`AutoStream::lock`] in loops to avoid the performance hit of acquiring/releasing +/// from the implicit locking in each [`std::io::Write`] call +#[cfg(feature = "auto")] +pub fn stdout() -> AutoStream<std::io::Stdout> { + let stdout = std::io::stdout(); + AutoStream::auto(stdout) +} + +/// Create an ANSI escape code compatible stderr +/// +/// **Note:** Call [`AutoStream::lock`] in loops to avoid the performance hit of acquiring/releasing +/// from the implicit locking in each [`std::io::Write`] call +#[cfg(feature = "auto")] +pub fn stderr() -> AutoStream<std::io::Stderr> { + let stderr = std::io::stderr(); + AutoStream::auto(stderr) +} + +/// Selection for overriding color output with [`force_color`] +#[cfg(feature = "auto")] +pub use concolor_override::ColorChoice; + +/// Override the detected [`ColorChoice`] +#[cfg(feature = "auto")] +pub fn force_color(choice: ColorChoice) { + concolor_override::set(choice); +} diff --git a/vendor/anstream/src/lockable.rs b/vendor/anstream/src/lockable.rs new file mode 100644 index 000000000..fcf20e317 --- /dev/null +++ b/vendor/anstream/src/lockable.rs @@ -0,0 +1,48 @@ +#[cfg(all(windows, feature = "wincon"))] +use crate::RawStream; + +/// Explicitly lock a [`std::io::Write`]able +pub trait Lockable { + type Locked; + + /// Get exclusive access to the `AutoStream` + /// + /// Why? + /// - Faster performance when writing in a loop + /// - Avoid other threads interleaving output with the current thread + fn lock(self) -> Self::Locked; +} + +impl Lockable for std::io::Stdout { + type Locked = std::io::StdoutLock<'static>; + + #[inline] + fn lock(self) -> Self::Locked { + #[allow(clippy::needless_borrow)] // Its needed to avoid recursion + (&self).lock() + } +} + +impl Lockable for std::io::Stderr { + type Locked = std::io::StderrLock<'static>; + + #[inline] + fn lock(self) -> Self::Locked { + #[allow(clippy::needless_borrow)] // Its needed to avoid recursion + (&self).lock() + } +} + +#[cfg(all(windows, feature = "wincon"))] +impl<S> Lockable for anstyle_wincon::Console<S> +where + S: RawStream + Lockable, + <S as Lockable>::Locked: RawStream, +{ + type Locked = anstyle_wincon::Console<<S as Lockable>::Locked>; + + #[inline] + fn lock(self) -> Self::Locked { + self.map(|s| s.lock()) + } +} diff --git a/vendor/anstream/src/macros.rs b/vendor/anstream/src/macros.rs new file mode 100644 index 000000000..ea9095944 --- /dev/null +++ b/vendor/anstream/src/macros.rs @@ -0,0 +1,313 @@ +/// Prints to [`stdout`][crate::stdout]. +/// +/// Equivalent to the [`println!`] macro except that a newline is not printed at +/// the end of the message. +/// +/// Note that stdout is frequently line-buffered by default so it may be +/// necessary to use [`std::io::Write::flush()`] to ensure the output is emitted +/// immediately. +/// +/// **NOTE:** The `print!` macro will lock the standard output on each call. If you call +/// `print!` within a hot loop, this behavior may be the bottleneck of the loop. +/// To avoid this, lock stdout with [`AutoStream::lock`][crate::AutoStream::lock]: +/// ``` +/// # #[cfg(feature = "auto")] { +/// use std::io::Write as _; +/// +/// let mut lock = anstream::stdout().lock(); +/// write!(lock, "hello world").unwrap(); +/// # } +/// ``` +/// +/// Use `print!` only for the primary output of your program. Use +/// [`eprint!`] instead to print error and progress messages. +/// +/// # Panics +/// +/// Panics if writing to `stdout` fails for any reason **except** broken pipe. +/// +/// Writing to non-blocking stdout can cause an error, which will lead +/// this macro to panic. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "auto")] { +/// use std::io::Write as _; +/// use anstream::print; +/// use anstream::stdout; +/// +/// print!("this "); +/// print!("will "); +/// print!("be "); +/// print!("on "); +/// print!("the "); +/// print!("same "); +/// print!("line "); +/// +/// stdout().flush().unwrap(); +/// +/// print!("this string has a newline, why not choose println! instead?\n"); +/// +/// stdout().flush().unwrap(); +/// # } +/// ``` +#[cfg(feature = "auto")] +#[macro_export] +macro_rules! print { + ($($arg:tt)*) => {{ + use std::io::Write as _; + + let mut stream = $crate::stdout(); + match ::std::write!(&mut stream, $($arg)*) { + Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => { + ::std::panic!("failed printing to stdout: {e}"); + } + Err(_) | Ok(_) => {} + } + }}; +} + +/// Prints to [`stdout`][crate::stdout], with a newline. +/// +/// On all platforms, the newline is the LINE FEED character (`\n`/`U+000A`) alone +/// (no additional CARRIAGE RETURN (`\r`/`U+000D`)). +/// +/// This macro uses the same syntax as [`format!`], but writes to the standard output instead. +/// See [`std::fmt`] for more information. +/// +/// **NOTE:** The `println!` macro will lock the standard output on each call. If you call +/// `println!` within a hot loop, this behavior may be the bottleneck of the loop. +/// To avoid this, lock stdout with [`AutoStream::lock`][crate::AutoStream::lock]: +/// ``` +/// # #[cfg(feature = "auto")] { +/// use std::io::Write as _; +/// +/// let mut lock = anstream::stdout().lock(); +/// writeln!(lock, "hello world").unwrap(); +/// # } +/// ``` +/// +/// Use `println!` only for the primary output of your program. Use +/// [`eprintln!`] instead to print error and progress messages. +/// +/// # Panics +/// +/// Panics if writing to `stdout` fails for any reason **except** broken pipe. +/// +/// Writing to non-blocking stdout can cause an error, which will lead +/// this macro to panic. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "auto")] { +/// use anstream::println; +/// +/// println!(); // prints just a newline +/// println!("hello there!"); +/// println!("format {} arguments", "some"); +/// let local_variable = "some"; +/// println!("format {local_variable} arguments"); +/// # } +/// ``` +#[cfg(feature = "auto")] +#[macro_export] +macro_rules! println { + () => { + $crate::print!("\n") + }; + ($($arg:tt)*) => {{ + use std::io::Write as _; + + let mut stream = $crate::stdout(); + match ::std::writeln!(&mut stream, $($arg)*) { + Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => { + ::std::panic!("failed printing to stdout: {e}"); + } + Err(_) | Ok(_) => {} + } + }}; +} + +/// Prints to [`stderr`][crate::stderr]. +/// +/// Equivalent to the [`print!`] macro, except that output goes to +/// `stderr` instead of `stdout`. See [`print!`] for +/// example usage. +/// +/// Use `eprint!` only for error and progress messages. Use `print!` +/// instead for the primary output of your program. +/// +/// # Panics +/// +/// Panics if writing to `stderr` fails for any reason **except** broken pipe. +/// +/// Writing to non-blocking stdout can cause an error, which will lead +/// this macro to panic. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "auto")] { +/// use anstream::eprint; +/// +/// eprint!("Error: Could not complete task"); +/// # } +/// ``` +#[cfg(feature = "auto")] +#[macro_export] +macro_rules! eprint { + ($($arg:tt)*) => {{ + use std::io::Write as _; + + let mut stream = $crate::stderr(); + match ::std::write!(&mut stream, $($arg)*) { + Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => { + ::std::panic!("failed printing to stdout: {e}"); + } + Err(_) | Ok(_) => {} + } + }}; +} + +/// Prints to [`stderr`][crate::stderr], with a newline. +/// +/// Equivalent to the [`println!`] macro, except that output goes to +/// `stderr` instead of `stdout`. See [`println!`] for +/// example usage. +/// +/// Use `eprintln!` only for error and progress messages. Use `println!` +/// instead for the primary output of your program. +/// +/// # Panics +/// +/// Panics if writing to `stderr` fails for any reason **except** broken pipe. +/// +/// Writing to non-blocking stdout can cause an error, which will lead +/// this macro to panic. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "auto")] { +/// use anstream::eprintln; +/// +/// eprintln!("Error: Could not complete task"); +/// # } +/// ``` +#[cfg(feature = "auto")] +#[macro_export] +macro_rules! eprintln { + () => { + $crate::eprint!("\n") + }; + ($($arg:tt)*) => {{ + use std::io::Write as _; + + let mut stream = $crate::stderr(); + match ::std::writeln!(&mut stream, $($arg)*) { + Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => { + ::std::panic!("failed printing to stdout: {e}"); + } + Err(_) | Ok(_) => {} + } + }}; +} + +/// Panics the current thread. +/// +/// This allows a program to terminate immediately and provide feedback +/// to the caller of the program. +/// +/// This macro is the perfect way to assert conditions in example code and in +/// tests. `panic!` is closely tied with the `unwrap` method of both +/// [`Option`][ounwrap] and [`Result`][runwrap] enums. Both implementations call +/// `panic!` when they are set to [`None`] or [`Err`] variants. +/// +/// When using `panic!()` you can specify a string payload, that is built using +/// the [`format!`] syntax. That payload is used when injecting the panic into +/// the calling Rust thread, causing the thread to panic entirely. +/// +/// The behavior of the default `std` hook, i.e. the code that runs directly +/// after the panic is invoked, is to print the message payload to +/// `stderr` along with the file/line/column information of the `panic!()` +/// call. You can override the panic hook using [`std::panic::set_hook()`]. +/// Inside the hook a panic can be accessed as a `&dyn Any + Send`, +/// which contains either a `&str` or `String` for regular `panic!()` invocations. +/// To panic with a value of another other type, [`panic_any`] can be used. +/// +/// See also the macro [`compile_error!`], for raising errors during compilation. +/// +/// # When to use `panic!` vs `Result` +/// +/// The Rust language provides two complementary systems for constructing / +/// representing, reporting, propagating, reacting to, and discarding errors. These +/// responsibilities are collectively known as "error handling." `panic!` and +/// `Result` are similar in that they are each the primary interface of their +/// respective error handling systems; however, the meaning these interfaces attach +/// to their errors and the responsibilities they fulfill within their respective +/// error handling systems differ. +/// +/// The `panic!` macro is used to construct errors that represent a bug that has +/// been detected in your program. With `panic!` you provide a message that +/// describes the bug and the language then constructs an error with that message, +/// reports it, and propagates it for you. +/// +/// `Result` on the other hand is used to wrap other types that represent either +/// the successful result of some computation, `Ok(T)`, or error types that +/// represent an anticipated runtime failure mode of that computation, `Err(E)`. +/// `Result` is used alongside user defined types which represent the various +/// anticipated runtime failure modes that the associated computation could +/// encounter. `Result` must be propagated manually, often with the the help of the +/// `?` operator and `Try` trait, and they must be reported manually, often with +/// the help of the `Error` trait. +/// +/// For more detailed information about error handling check out the [book] or the +/// [`std::result`] module docs. +/// +/// [ounwrap]: Option::unwrap +/// [runwrap]: Result::unwrap +/// [`std::panic::set_hook()`]: ../std/panic/fn.set_hook.html +/// [`panic_any`]: ../std/panic/fn.panic_any.html +/// [`Box`]: ../std/boxed/struct.Box.html +/// [`Any`]: crate::any::Any +/// [`format!`]: ../std/macro.format.html +/// [book]: ../book/ch09-00-error-handling.html +/// [`std::result`]: ../std/result/index.html +/// +/// # Current implementation +/// +/// If the main thread panics it will terminate all your threads and end your +/// program with code `101`. +/// +/// # Examples +/// +/// ```should_panic +/// # #![allow(unreachable_code)] +/// use anstream::panic; +/// panic!(); +/// panic!("this is a terrible mistake!"); +/// panic!("this is a {} {message}", "fancy", message = "message"); +/// ``` +#[cfg(feature = "auto")] +#[macro_export] +macro_rules! panic { + () => { + ::std::panic!() + }; + ($($arg:tt)*) => {{ + use std::io::Write as _; + + let panic_stream = std::io::stderr(); + let choice = $crate::AutoStream::choice(&panic_stream); + let buffer = $crate::Buffer::new(); + let mut stream = $crate::AutoStream::new(buffer, choice); + // Ignore errors rather than panic + let _ = ::std::write!(&mut stream, $($arg)*); + let buffer = stream.into_inner(); + // Should be UTF-8 but not wanting to panic + let buffer = String::from_utf8_lossy(buffer.as_bytes()).into_owned(); + ::std::panic!("{}", buffer) + }}; +} diff --git a/vendor/anstream/src/raw.rs b/vendor/anstream/src/raw.rs new file mode 100644 index 000000000..d81db28c1 --- /dev/null +++ b/vendor/anstream/src/raw.rs @@ -0,0 +1,42 @@ +/// Required functionality for underlying [`std::io::Write`] for adaptation +#[cfg(not(any(feature = "auto", all(windows, feature = "wincon"))))] +pub trait RawStream: std::io::Write + private::Sealed {} + +/// Required functionality for underlying [`std::io::Write`] for adaptation +#[cfg(all(feature = "auto", not(all(windows, feature = "wincon"))))] +pub trait RawStream: std::io::Write + is_terminal::IsTerminal + private::Sealed {} + +/// Required functionality for underlying [`std::io::Write`] for adaptation +#[cfg(all(not(feature = "auto"), all(windows, feature = "wincon")))] +pub trait RawStream: std::io::Write + anstyle_wincon::WinconStream + private::Sealed {} + +/// Required functionality for underlying [`std::io::Write`] for adaptation +#[cfg(all(feature = "auto", all(windows, feature = "wincon")))] +pub trait RawStream: + std::io::Write + is_terminal::IsTerminal + anstyle_wincon::WinconStream + private::Sealed +{ +} + +impl RawStream for std::io::Stdout {} + +impl RawStream for std::io::StdoutLock<'static> {} + +impl RawStream for std::io::Stderr {} + +impl RawStream for std::io::StderrLock<'static> {} + +impl RawStream for crate::Buffer {} + +mod private { + pub trait Sealed {} + + impl Sealed for std::io::Stdout {} + + impl Sealed for std::io::StdoutLock<'static> {} + + impl Sealed for std::io::Stderr {} + + impl Sealed for std::io::StderrLock<'static> {} + + impl Sealed for crate::Buffer {} +} diff --git a/vendor/anstream/src/strip.rs b/vendor/anstream/src/strip.rs new file mode 100644 index 000000000..0dd017497 --- /dev/null +++ b/vendor/anstream/src/strip.rs @@ -0,0 +1,196 @@ +use crate::adapter::StripBytes; +use crate::Lockable; +use crate::RawStream; + +/// Only pass printable data to the inner `Write` +#[derive(Debug)] +pub struct StripStream<S> { + raw: S, + state: StripBytes, +} + +impl<S> StripStream<S> +where + S: RawStream, +{ + /// Only pass printable data to the inner `Write` + #[inline] + pub fn new(raw: S) -> Self { + Self { + raw, + state: Default::default(), + } + } + + /// Get the wrapped [`RawStream`] + #[inline] + pub fn into_inner(self) -> S { + self.raw + } + + #[inline] + #[cfg(feature = "auto")] + pub fn is_terminal(&self) -> bool { + self.raw.is_terminal() + } +} + +#[cfg(feature = "auto")] +impl<S> is_terminal::IsTerminal for StripStream<S> +where + S: RawStream, +{ + #[inline] + fn is_terminal(&self) -> bool { + self.is_terminal() + } +} + +impl<S> std::io::Write for StripStream<S> +where + S: RawStream, +{ + #[inline] + fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> { + write(&mut self.raw, &mut self.state, buf) + } + + #[inline] + fn flush(&mut self) -> std::io::Result<()> { + self.raw.flush() + } + + // Provide explicit implementations of trait methods + // - To reduce bookkeeping + // - Avoid acquiring / releasing locks in a loop + + #[inline] + fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> { + write_all(&mut self.raw, &mut self.state, buf) + } + + // Not bothering with `write_fmt` as it just calls `write_all` +} + +fn write( + raw: &mut dyn std::io::Write, + state: &mut StripBytes, + buf: &[u8], +) -> std::io::Result<usize> { + let initial_state = state.clone(); + + for printable in state.strip_next(buf) { + let possible = printable.len(); + let written = raw.write(printable)?; + if possible != written { + let divergence = &printable[written..]; + let offset = offset_to(buf, divergence); + let consumed = &buf[offset..]; + *state = initial_state; + state.strip_next(consumed).last(); + return Ok(offset); + } + } + Ok(buf.len()) +} + +fn write_all( + raw: &mut dyn std::io::Write, + state: &mut StripBytes, + buf: &[u8], +) -> std::io::Result<()> { + for printable in state.strip_next(buf) { + raw.write_all(printable)?; + } + Ok(()) +} + +#[inline] +fn offset_to(total: &[u8], subslice: &[u8]) -> usize { + let total = total.as_ptr(); + let subslice = subslice.as_ptr(); + + debug_assert!( + total <= subslice, + "`Offset::offset_to` only accepts slices of `self`" + ); + subslice as usize - total as usize +} + +impl<S> Lockable for StripStream<S> +where + S: Lockable, +{ + type Locked = StripStream<<S as Lockable>::Locked>; + + #[inline] + fn lock(self) -> Self::Locked { + Self::Locked { + raw: self.raw.lock(), + state: self.state, + } + } +} + +#[cfg(test)] +mod test { + use super::*; + use proptest::prelude::*; + use std::io::Write as _; + + proptest! { + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_all_no_escapes(s in "\\PC*") { + let buffer = crate::Buffer::new(); + let mut stream = StripStream::new(buffer); + stream.write_all(s.as_bytes()).unwrap(); + let buffer = stream.into_inner(); + let actual = std::str::from_utf8(buffer.as_ref()).unwrap(); + assert_eq!(s, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_byte_no_escapes(s in "\\PC*") { + let buffer = crate::Buffer::new(); + let mut stream = StripStream::new(buffer); + for byte in s.as_bytes() { + stream.write_all(&[*byte]).unwrap(); + } + let buffer = stream.into_inner(); + let actual = std::str::from_utf8(buffer.as_ref()).unwrap(); + assert_eq!(s, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_all_random(s in any::<Vec<u8>>()) { + let buffer = crate::Buffer::new(); + let mut stream = StripStream::new(buffer); + stream.write_all(s.as_slice()).unwrap(); + let buffer = stream.into_inner(); + if let Ok(actual) = std::str::from_utf8(buffer.as_ref()) { + for char in actual.chars() { + assert!(!char.is_ascii() || !char.is_control() || char.is_ascii_whitespace(), "{:?} -> {:?}: {:?}", String::from_utf8_lossy(&s), actual, char); + } + } + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_byte_random(s in any::<Vec<u8>>()) { + let buffer = crate::Buffer::new(); + let mut stream = StripStream::new(buffer); + for byte in s.as_slice() { + stream.write_all(&[*byte]).unwrap(); + } + let buffer = stream.into_inner(); + if let Ok(actual) = std::str::from_utf8(buffer.as_ref()) { + for char in actual.chars() { + assert!(!char.is_ascii() || !char.is_control() || char.is_ascii_whitespace(), "{:?} -> {:?}: {:?}", String::from_utf8_lossy(&s), actual, char); + } + } + } + } +} diff --git a/vendor/anstream/src/wincon.rs b/vendor/anstream/src/wincon.rs new file mode 100644 index 000000000..6627bbb59 --- /dev/null +++ b/vendor/anstream/src/wincon.rs @@ -0,0 +1,154 @@ +use crate::adapter::WinconBytes; +use crate::Lockable; +use crate::RawStream; + +/// Only pass printable data to the inner `Write` +#[cfg(feature = "wincon")] // here mostly for documentation purposes +#[derive(Debug)] +pub struct WinconStream<S> +where + S: RawStream, +{ + console: anstyle_wincon::Console<S>, + // `WinconBytes` is especially large compared to other variants of `AutoStream`, so boxing it + // here so `AutoStream` doesn't have to discard one allocation and create another one when + // calling `AutoStream::lock` + state: Box<WinconBytes>, +} + +impl<S> WinconStream<S> +where + S: RawStream, +{ + /// Only pass printable data to the inner `Write` + #[inline] + pub fn new(console: anstyle_wincon::Console<S>) -> Self { + Self { + console, + state: Box::default(), + } + } + + /// Get the wrapped [`RawStream`] + #[inline] + pub fn into_inner(self) -> anstyle_wincon::Console<S> { + self.console + } + + #[inline] + #[cfg(feature = "auto")] + pub fn is_terminal(&self) -> bool { + // HACK: We can't get the console's stream to check but if there is a console, it likely is + // a terminal + true + } +} + +#[cfg(feature = "auto")] +impl<S> is_terminal::IsTerminal for WinconStream<S> +where + S: RawStream, +{ + #[inline] + fn is_terminal(&self) -> bool { + self.is_terminal() + } +} + +impl<S> std::io::Write for WinconStream<S> +where + S: RawStream, +{ + fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> { + for (style, printable) in self.state.extract_next(buf) { + let fg = style.get_fg_color().and_then(cap_wincon_color); + let bg = style.get_bg_color().and_then(cap_wincon_color); + let written = self.console.write(fg, bg, printable.as_bytes())?; + let possible = printable.len(); + if possible != written { + // HACK: Unsupported atm + break; + } + } + Ok(buf.len()) + } + #[inline] + fn flush(&mut self) -> std::io::Result<()> { + self.console.flush() + } +} + +impl<S> Lockable for WinconStream<S> +where + S: RawStream + Lockable, + <S as Lockable>::Locked: RawStream, +{ + type Locked = WinconStream<<S as Lockable>::Locked>; + + #[inline] + fn lock(self) -> Self::Locked { + Self::Locked { + console: self.console.lock(), + state: self.state, + } + } +} + +fn cap_wincon_color(color: anstyle::Color) -> Option<anstyle::AnsiColor> { + match color { + anstyle::Color::Ansi(c) => Some(c), + anstyle::Color::Ansi256(c) => c.into_ansi(), + anstyle::Color::Rgb(_) => None, + } +} + +#[cfg(test)] +mod test { + use super::*; + use proptest::prelude::*; + use std::io::Write as _; + + proptest! { + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_all_no_escapes(s in "\\PC*") { + let buffer = crate::Buffer::new(); + let mut stream = WinconStream::new(anstyle_wincon::Console::new(buffer).unwrap()); + stream.write_all(s.as_bytes()).unwrap(); + let buffer = stream.into_inner().into_inner(); + let actual = std::str::from_utf8(buffer.as_ref()).unwrap(); + assert_eq!(s, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_byte_no_escapes(s in "\\PC*") { + let buffer = crate::Buffer::new(); + let mut stream = WinconStream::new(anstyle_wincon::Console::new(buffer).unwrap()); + for byte in s.as_bytes() { + stream.write_all(&[*byte]).unwrap(); + } + let buffer = stream.into_inner().into_inner(); + let actual = std::str::from_utf8(buffer.as_ref()).unwrap(); + assert_eq!(s, actual); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_all_random(s in any::<Vec<u8>>()) { + let buffer = crate::Buffer::new(); + let mut stream = WinconStream::new(anstyle_wincon::Console::new(buffer).unwrap()); + stream.write_all(s.as_slice()).unwrap(); + } + + #[test] + #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 + fn write_byte_random(s in any::<Vec<u8>>()) { + let buffer = crate::Buffer::new(); + let mut stream = WinconStream::new(anstyle_wincon::Console::new(buffer).unwrap()); + for byte in s.as_slice() { + stream.write_all(&[*byte]).unwrap(); + } + } + } +} |