diff options
Diffstat (limited to 'vendor/tempfile')
| -rw-r--r-- | vendor/tempfile/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | vendor/tempfile/CHANGELOG.md | 267 | ||||
| -rw-r--r-- | vendor/tempfile/Cargo.toml | 59 | ||||
| -rw-r--r-- | vendor/tempfile/LICENSE-APACHE | 201 | ||||
| -rw-r--r-- | vendor/tempfile/LICENSE-MIT | 25 | ||||
| -rw-r--r-- | vendor/tempfile/README.md | 46 | ||||
| -rw-r--r-- | vendor/tempfile/deny.toml | 40 | ||||
| -rw-r--r-- | vendor/tempfile/src/dir.rs | 477 | ||||
| -rw-r--r-- | vendor/tempfile/src/error.rs | 45 | ||||
| -rw-r--r-- | vendor/tempfile/src/file/imp/mod.rs | 12 | ||||
| -rw-r--r-- | vendor/tempfile/src/file/imp/other.rs | 30 | ||||
| -rw-r--r-- | vendor/tempfile/src/file/imp/unix.rs | 149 | ||||
| -rw-r--r-- | vendor/tempfile/src/file/imp/windows.rs | 104 | ||||
| -rw-r--r-- | vendor/tempfile/src/file/mod.rs | 1124 | ||||
| -rw-r--r-- | vendor/tempfile/src/lib.rs | 701 | ||||
| -rw-r--r-- | vendor/tempfile/src/spooled.rs | 203 | ||||
| -rw-r--r-- | vendor/tempfile/src/util.rs | 47 | ||||
| -rw-r--r-- | vendor/tempfile/tests/namedtempfile.rs | 473 | ||||
| -rw-r--r-- | vendor/tempfile/tests/spooled.rs | 307 | ||||
| -rw-r--r-- | vendor/tempfile/tests/tempdir.rs | 176 | ||||
| -rw-r--r-- | vendor/tempfile/tests/tempfile.rs | 68 |
21 files changed, 0 insertions, 4555 deletions
diff --git a/vendor/tempfile/.cargo-checksum.json b/vendor/tempfile/.cargo-checksum.json deleted file mode 100644 index bc37aae..0000000 --- a/vendor/tempfile/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{"CHANGELOG.md":"6ca436fe5f63922174c061cb402e9b5a1e455b66a3b5677d1c191c04962b5832","Cargo.toml":"c79c844a01b8c7aec169d6506a3c588edacdfcdc835d2577b14dc064b342ac75","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"8b427f5bc501764575e52ba4f9d95673cf8f6d80a86d0d06599852e1a9a20a36","README.md":"972f1c35ec653943e067fd2c3d09e78f593b2e9e1eafd5b9668bf3653513de3e","deny.toml":"cb4c35327cbf8a20a6b19ac3fdf2c47b665da1662c90e3eae8a3825f9b72596e","src/dir.rs":"3b515f42feb934ba83ba56d506116e5e932c6b863b764fd61d26994eff28700a","src/error.rs":"cc7d8eace0fff11cb342158d2885d5637bfb14b24ef30755e808554772039c5f","src/file/imp/mod.rs":"f6da9fcd93f11889670a251fdd8231b5f4614e5a971b7b183f52b44af68568d5","src/file/imp/other.rs":"501cd1b444a5821127ea831fc8018706148f2d9f47c478f502b069963a42a2c7","src/file/imp/unix.rs":"0fa63a8b831947fdc7307e889d129adef6f47b19965b963a5e25d70cb3106e62","src/file/imp/windows.rs":"fa4211087c36290064de9a41b5e533e4e8c24a10fb8f8908835a67e00555c06e","src/file/mod.rs":"3a51ab219e0adab18324cab072fed01b0805781d6f15e79ca8b8a36543683bcc","src/lib.rs":"6303e7470c680ad785f32eb717de2e512b88c2c5da0e1684e3704471fabd7398","src/spooled.rs":"de848218bb7c0733d9c46e337564137673c95f5a6cf9f6bb28baf218b2503247","src/util.rs":"63737b9180cb769c1fcac56f1fa928221ae41a8917872d3e878d0a915e877710","tests/namedtempfile.rs":"87dd6a8bba2fdd77418ec2b50b8aec5e26d05a2f780182b4e9ff464b3404d47c","tests/spooled.rs":"a97e96404dc5136421ac027b965070c0d5b44c93d06d456e12dc85f81755d064","tests/tempdir.rs":"f5a86f56df6bb60aa5dfa136ce75f8d0f29c2e87546dccfe1fb680d209be525e","tests/tempfile.rs":"9a2f8142151a6aa2fd047aa3749f9982ece4b080a3ace0d3c58d6bdb3f883c81"},"package":"01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa"}
\ No newline at end of file diff --git a/vendor/tempfile/CHANGELOG.md b/vendor/tempfile/CHANGELOG.md deleted file mode 100644 index e8894b3..0000000 --- a/vendor/tempfile/CHANGELOG.md +++ /dev/null @@ -1,267 +0,0 @@ -# Changelog - -## 3.9.0 - -- Updates windows-sys to 0.52 -- Updates minimum rustix version to 0.38.25 - -## 3.8.1 - -- Update rustix to fix a potential panic on `persist_noclobber` on android. -- Update redox_syscall to 0.4 (on redox). -- Fix some docs typos. - -## 3.8.0 - -- Added `with_prefix` and `with_prefix_in` to `TempDir` and `NamedTempFile` to make it easier to create temporary files/directories with nice prefixes. -- Misc cleanups. - -## 3.7.1 - -- Tempfile builds on haiku again. -- Under the hood, we've switched from the unlinkat/linkat syscalls to the regular unlink/link syscalls where possible. - -## 3.7.0 - -BREAKING: This release updates the MSRV to 1.63. This isn't an API-breaking change (so no major -release) but it's still a breaking change for some users. - -- Update fastrand from 1.6 to 2.0 -- Update rustix to 0.38 -- Updates the MSRV to 1.63. -- Provide AsFd/AsRawFd on wasi. - -## 3.6.0 - -- Update windows-sys to 0.48. -- Update rustix min version to 0.37.11 -- Forward some `NamedTempFile` and `SpooledTempFile` methods to the underlying `File` object for - better performance (especially vectorized writes, etc.). -- Implement `AsFd` and `AsHandle`. -- Misc documentation fixes and code cleanups. - -## 3.5.0 - -- Update rustix from 0.36 to 0.37.1. This makes wasi work on rust stable -- Update `windows-sys`, `redox_syscall` -- BREAKING: Remove the implementation of `Write for &NamedTempFile<F> where &F: Write`. Unfortunately, this can cause compile issues in unrelated code (https://github.com/Stebalien/tempfile/issues/224). - -## 3.4.0 - -SECURITY: Prior `tempfile` releases depended on `remove_dir_all` version 0.5.0 which was vulnerable to a [TOCTOU race](https://github.com/XAMPPRocky/remove_dir_all/security/advisories/GHSA-mc8h-8q98-g5hr). This same race is present in rust versions prior to 1.58.1. - -Features: - -- Generalized temporary files: `NamedTempFile` can now abstract over different kinds of files (e.g., - unix domain sockets, pipes, etc.): - - Add `Builder::make` and `Builder::make_in` for generalized temp file - creation. - - Add `NamedTempFile::from_parts` to complement `NamedTempFile::into_parts`. - - Add generic parameter to `NamedTempFile` to support wrapping non-File types. - -Bug Fixes/Improvements: - -- Don't try to create a temporary file multiple times if the file path has been fully specified by - the user (no random characters). -- `NamedTempFile::persist_noclobber` is now always atomic on linux when `renameat_with` is - supported. Previously, it would first link the new path, then unlink the previous path. -- Fix compiler warnings on windows. - -Trivia: - -- Switch from `libc` to `rustix` on wasi/unix. This now makes direct syscalls instead of calling - through libc. -- Remove `remove_dir_all` dependency. The rust standard library has optimized their internal version - significantly. - - Switch to official windows-sys windows bindings. - -Breaking: - - - The minimum rust version is now `1.48.0`. - - Mark most functions as `must_use`. - - Uses direct syscalls on linux by default, instead of libc. - - The new type parameter in `NamedTempFile` may lead to type inference issues in some cases. - -## 3.3.0 - -Features: - -- Replace rand with fastrand for a significantly smaller dependency tree. Cryptographic randomness - isn't necessary for temporary file names, and isn't all that helpful either. -- Add limited WASI support. -- Add a function to extract the inner data from a `SpooledTempFile`. - -Bug Fixes: - -- Make it possible to persist unnamed temporary files on linux by removing the `O_EXCL` flag. -- Fix redox minimum crate version. - -## 3.2.0 - -Features: - -- Bump rand dependency to `0.8`. -- Bump cfg-if dependency to `1.0` - -Other than that, this release mostly includes small cleanups and simplifications. - -Breaking: The minimum rust version is now `1.40.0`. - -## 3.1.0 - -Features: - -- Bump rand dependency to `0.7`. - -Breaking: The minimum rust version is now `1.32.0`. - -## 3.0.9 - -Documentation: - -- Add an example for reopening a named temporary file. -- Flesh out the security documentation. - -Features: - -- Introduce an `append` option to the builder. -- Errors: - - No longer implement the soft-deprecated `description`. - - Implement `source` instead of `cause`. - -Breaking: The minimum rust version is now 1.30. - -## 3.0.8 - -This is a bugfix release. - -Fixes: - -- Export `PathPersistError`. -- Fix a bug where flushing a `SpooledTempFile` to disk could fail to write part - of the file in some rare, yet-to-reproduced cases. - -## 3.0.7 - -Breaking: - -- `Builder::prefix` and `Builder::suffix` now accept a generic `&AsRef<OsStr>`. - This could affect type inference. -- Temporary files (except unnamed temporary files on Windows and Linux >= 3.11) - now use absolute path names. This will break programs that create temporary - files relative to their current working directory when they don't have the - search permission (x) on some ancestor directory. This is only likely to - affect programs with strange chroot-less filesystem sandboxes. If you believe - you're affected by this issue, please comment on #40. - -Features: - -- Accept anything implementing `&AsRef<OsStr>` in the builder: &OsStr, &OsString, &Path, etc. - -Fixes: - -- Fix LFS support. -- Use absolute paths for named temporary files to guard against changes in the - current directory. -- Use absolute paths when creating unnamed temporary files on platforms that - can't create unlinked or auto-deleted temporary files. This fixes a very - unlikely race where the current directory could change while the temporary - file is being created. - -Misc: - -- Use modern stdlib features to avoid custom unsafe code. This reduces the - number of unsafe blocks from 12 to 4. - -## 3.0.6 - -- Don't hide temporary files on windows, fixing #66 and #69. - -## 3.0.5 - -Features: - -- Added a spooled temporary file implementation. This temporary file variant - starts out as an in-memory temporary file but "rolls-over" onto disk when it - grows over a specified size (#68). -- Errors are now annotated with paths to make debugging easier (#73). - -Misc: - -- The rand version has been bumped to 0.6 (#74). - -Bugs: - -- Tempfile compiles again on Redox (#75). - -## 3.0.4 - -- Now compiles on unsupported platforms. - -## 3.0.3 - -- update rand to 0.5 - -## 3.0.2 - -- Actually *delete* temporary files on non-Linux unix systems (thanks to -@oliverhenshaw for the fix and a test case). - -## 3.0.1 - -- Restore NamedTempFile::new_in - -## 3.0.0 - -- Adds temporary directory support (@KodrAus) -- Allow closing named temporary files without deleting them (@jasonwhite) - -## 2.2.0 - -- Redox Support - -## 2.1.6 - -- Remove build script and bump minimum rustc version to 1.9.0 - -## 2.1.5 - -- Don't build platform-specific dependencies on all platforms. -- Cleanup some documentation. - -## 2.1.4 - -- Fix crates.io tags. No interesting changes. - -## 2.1.3 - -Export `PersistError`. - -## 2.1.2 - -Add `Read`/`Write`/`Seek` impls on `&NamedTempFile`. This mirrors the -implementations on `&File`. One can currently just deref to a `&File` but these -implementations are more discoverable. - -## 2.1.1 - -Add LFS Support. - -## 2.1.0 - -- Implement `AsRef<File>` for `NamedTempFile` allowing named temporary files to - be borrowed as `File`s. -- Add a method to convert a `NamedTempFile` to an unnamed temporary `File`. - -## 2.0.1 - -- Arm bugfix - -## 2.0.0 - -This release replaces `TempFile` with a `tempfile()` function that returns -`std::fs::File` objects. These are significantly more useful because most rust -libraries expect normal `File` objects. - -To continue supporting shared temporary files, this new version adds a -`reopen()` method to `NamedTempFile`. diff --git a/vendor/tempfile/Cargo.toml b/vendor/tempfile/Cargo.toml deleted file mode 100644 index 4c2c2e5..0000000 --- a/vendor/tempfile/Cargo.toml +++ /dev/null @@ -1,59 +0,0 @@ -# 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 = "2018" -rust-version = "1.63" -name = "tempfile" -version = "3.9.0" -authors = [ - "Steven Allen <steven@stebalien.com>", - "The Rust Project Developers", - "Ashley Mannix <ashleymannix@live.com.au>", - "Jason White <me@jasonwhite.io>", -] -description = "A library for managing temporary files and directories." -homepage = "https://stebalien.com/projects/tempfile-rs/" -documentation = "https://docs.rs/tempfile" -readme = "README.md" -keywords = [ - "tempfile", - "tmpfile", - "filesystem", -] -license = "MIT OR Apache-2.0" -repository = "https://github.com/Stebalien/tempfile" - -[dependencies.cfg-if] -version = "1" - -[dependencies.fastrand] -version = "2.0.0" - -[dev-dependencies.doc-comment] -version = "0.3" - -[features] -nightly = [] - -[target."cfg(any(unix, target_os = \"wasi\"))".dependencies.rustix] -version = "0.38.26" -features = ["fs"] - -[target."cfg(target_os = \"redox\")".dependencies.redox_syscall] -version = "0.4" - -[target."cfg(windows)".dependencies.windows-sys] -version = "0.52" -features = [ - "Win32_Storage_FileSystem", - "Win32_Foundation", -] diff --git a/vendor/tempfile/LICENSE-APACHE b/vendor/tempfile/LICENSE-APACHE deleted file mode 100644 index 16fe87b..0000000 --- a/vendor/tempfile/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - 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/tempfile/LICENSE-MIT b/vendor/tempfile/LICENSE-MIT deleted file mode 100644 index 0c3270f..0000000 --- a/vendor/tempfile/LICENSE-MIT +++ /dev/null @@ -1,25 +0,0 @@ -Copyright (c) 2015 Steven Allen - -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/tempfile/README.md b/vendor/tempfile/README.md deleted file mode 100644 index 4d886b1..0000000 --- a/vendor/tempfile/README.md +++ /dev/null @@ -1,46 +0,0 @@ -tempfile -======== - -[](https://crates.io/crates/tempfile) -[](https://github.com/Stebalien/tempfile/actions/workflows/ci.yml?query=branch%3Amaster) - -A secure, cross-platform, temporary file library for Rust. In addition to creating -temporary files, this library also allows users to securely open multiple -independent references to the same temporary file (useful for consumer/producer -patterns and surprisingly difficult to implement securely). - -[Documentation](https://docs.rs/tempfile/) - -Usage ------ - -Minimum required Rust version: 1.63.0 - -Add this to your `Cargo.toml`: - -```toml -[dependencies] -tempfile = "3" -``` - -Example -------- - -```rust -use std::fs::File; -use std::io::{Write, Read, Seek, SeekFrom}; - -fn main() { - // Write - let mut tmpfile: File = tempfile::tempfile().unwrap(); - write!(tmpfile, "Hello World!").unwrap(); - - // Seek to start - tmpfile.seek(SeekFrom::Start(0)).unwrap(); - - // Read - let mut buf = String::new(); - tmpfile.read_to_string(&mut buf).unwrap(); - assert_eq!("Hello World!", buf); -} -``` diff --git a/vendor/tempfile/deny.toml b/vendor/tempfile/deny.toml deleted file mode 100644 index ce0ef1c..0000000 --- a/vendor/tempfile/deny.toml +++ /dev/null @@ -1,40 +0,0 @@ - -[advisories] -notice = "deny" -unmaintained = "deny" -vulnerability = "deny" -yanked = "deny" -ignore = [] - -[licenses] -allow = [ - "Apache-2.0", - "MIT", -] -default = "deny" -confidence-threshold = 1.0 -unlicensed = "deny" - -[bans] -allow = [] -deny = [] -multiple-versions = "deny" -skip = [ - # Transitive dependency of both redox_syscall and rustix (rustix has newer). - # - # Only one version of bitflags ultimately gets compiled in due to OS-based feature flags in tempfile. - { name = "bitflags" }, -] -skip-tree = [] -wildcards = "deny" - -[sources] -allow-git = [] -allow-registry = ["https://github.com/rust-lang/crates.io-index"] -unknown-git = "deny" -unknown-registry = "deny" - -[sources.allow-org] -github = [] -gitlab = [] -bitbucket = [] diff --git a/vendor/tempfile/src/dir.rs b/vendor/tempfile/src/dir.rs deleted file mode 100644 index 1b79be4..0000000 --- a/vendor/tempfile/src/dir.rs +++ /dev/null @@ -1,477 +0,0 @@ -// Copyright 2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::ffi::OsStr; -use std::fs::remove_dir_all; -use std::mem; -use std::path::{self, Path, PathBuf}; -use std::{fmt, fs, io}; - -use crate::error::IoResultExt; -use crate::Builder; - -/// Create a new temporary directory. -/// -/// The `tempdir` function creates a directory in the file system -/// and returns a [`TempDir`]. -/// The directory will be automatically deleted when the `TempDir`s -/// destructor is run. -/// -/// # Resource Leaking -/// -/// See [the resource leaking][resource-leaking] docs on `TempDir`. -/// -/// # Errors -/// -/// If the directory can not be created, `Err` is returned. -/// -/// # Examples -/// -/// ``` -/// use tempfile::tempdir; -/// use std::fs::File; -/// use std::io::{self, Write}; -/// -/// # fn main() { -/// # if let Err(_) = run() { -/// # ::std::process::exit(1); -/// # } -/// # } -/// # fn run() -> Result<(), io::Error> { -/// // Create a directory inside of `std::env::temp_dir()` -/// let tmp_dir = tempdir()?; -/// -/// let file_path = tmp_dir.path().join("my-temporary-note.txt"); -/// let mut tmp_file = File::create(file_path)?; -/// writeln!(tmp_file, "Brian was here. Briefly.")?; -/// -/// // `tmp_dir` goes out of scope, the directory as well as -/// // `tmp_file` will be deleted here. -/// drop(tmp_file); -/// tmp_dir.close()?; -/// # Ok(()) -/// # } -/// ``` -/// -/// [`TempDir`]: struct.TempDir.html -/// [resource-leaking]: struct.TempDir.html#resource-leaking -pub fn tempdir() -> io::Result<TempDir> { - TempDir::new() -} - -/// Create a new temporary directory in a specific directory. -/// -/// The `tempdir_in` function creates a directory in the specified directory -/// and returns a [`TempDir`]. -/// The directory will be automatically deleted when the `TempDir`s -/// destructor is run. -/// -/// # Resource Leaking -/// -/// See [the resource leaking][resource-leaking] docs on `TempDir`. -/// -/// # Errors -/// -/// If the directory can not be created, `Err` is returned. -/// -/// # Examples -/// -/// ``` -/// use tempfile::tempdir_in; -/// use std::fs::File; -/// use std::io::{self, Write}; -/// -/// # fn main() { -/// # if let Err(_) = run() { -/// # ::std::process::exit(1); -/// # } -/// # } -/// # fn run() -> Result<(), io::Error> { -/// // Create a directory inside of the current directory. -/// let tmp_dir = tempdir_in(".")?; -/// -/// let file_path = tmp_dir.path().join("my-temporary-note.txt"); -/// let mut tmp_file = File::create(file_path)?; -/// writeln!(tmp_file, "Brian was here. Briefly.")?; -/// -/// // `tmp_dir` goes out of scope, the directory as well as -/// // `tmp_file` will be deleted here. -/// drop(tmp_file); -/// tmp_dir.close()?; -/// # Ok(()) -/// # } -/// ``` -/// -/// [`TempDir`]: struct.TempDir.html -/// [resource-leaking]: struct.TempDir.html#resource-leaking -pub fn tempdir_in<P: AsRef<Path>>(dir: P) -> io::Result<TempDir> { - TempDir::new_in(dir) -} - -/// A directory in the filesystem that is automatically deleted when -/// it goes out of scope. -/// -/// The [`TempDir`] type creates a directory on the file system that -/// is deleted once it goes out of scope. At construction, the -/// `TempDir` creates a new directory with a randomly generated name. -/// -/// The default constructor, [`TempDir::new()`], creates directories in -/// the location returned by [`std::env::temp_dir()`], but `TempDir` -/// can be configured to manage a temporary directory in any location -/// by constructing with a [`Builder`]. -/// -/// After creating a `TempDir`, work with the file system by doing -/// standard [`std::fs`] file system operations on its [`Path`], -/// which can be retrieved with [`TempDir::path()`]. Once the `TempDir` -/// value is dropped, the directory at the path will be deleted, along -/// with any files and directories it contains. It is your responsibility -/// to ensure that no further file system operations are attempted -/// inside the temporary directory once it has been deleted. -/// -/// # Resource Leaking -/// -/// Various platform-specific conditions may cause `TempDir` to fail -/// to delete the underlying directory. It's important to ensure that -/// handles (like [`File`] and [`ReadDir`]) to files inside the -/// directory are dropped before the `TempDir` goes out of scope. The -/// `TempDir` destructor will silently ignore any errors in deleting -/// the directory; to instead handle errors call [`TempDir::close()`]. -/// -/// Note that if the program exits before the `TempDir` destructor is -/// run, such as via [`std::process::exit()`], by segfaulting, or by -/// receiving a signal like `SIGINT`, then the temporary directory -/// will not be deleted. -/// -/// # Examples -/// -/// Create a temporary directory with a generated name: -/// -/// ``` -/// use std::fs::File; -/// use std::io::Write; -/// use tempfile::TempDir; -/// -/// # use std::io; -/// # fn run() -> Result<(), io::Error> { -/// // Create a directory inside of `std::env::temp_dir()` -/// let tmp_dir = TempDir::new()?; -/// # Ok(()) -/// # } -/// ``` -/// -/// Create a temporary directory with a prefix in its name: -/// -/// ``` -/// use std::fs::File; -/// use std::io::Write; -/// use tempfile::Builder; -/// -/// # use std::io; -/// # fn run() -> Result<(), io::Error> { -/// // Create a directory inside of `std::env::temp_dir()`, -/// // whose name will begin with 'example'. -/// let tmp_dir = Builder::new().prefix("example").tempdir()?; -/// # Ok(()) -/// # } -/// ``` -/// -/// [`File`]: http://doc.rust-lang.org/std/fs/struct.File.html -/// [`Path`]: http://doc.rust-lang.org/std/path/struct.Path.html -/// [`ReadDir`]: http://doc.rust-lang.org/std/fs/struct.ReadDir.html -/// [`Builder`]: struct.Builder.html -/// [`TempDir::close()`]: struct.TempDir.html#method.close -/// [`TempDir::new()`]: struct.TempDir.html#method.new -/// [`TempDir::path()`]: struct.TempDir.html#method.path -/// [`TempDir`]: struct.TempDir.html -/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html -/// [`std::fs`]: http://doc.rust-lang.org/std/fs/index.html -/// [`std::process::exit()`]: http://doc.rust-lang.org/std/process/fn.exit.html -pub struct TempDir { - path: Box<Path>, -} - -impl TempDir { - /// Attempts to make a temporary directory inside of `env::temp_dir()`. - /// - /// See [`Builder`] for more configuration. - /// - /// The directory and everything inside it will be automatically deleted - /// once the returned `TempDir` is destroyed. - /// - /// # Errors - /// - /// If the directory can not be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// use std::fs::File; - /// use std::io::Write; - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// // Create a directory inside of `std::env::temp_dir()` - /// let tmp_dir = TempDir::new()?; - /// - /// let file_path = tmp_dir.path().join("my-temporary-note.txt"); - /// let mut tmp_file = File::create(file_path)?; - /// writeln!(tmp_file, "Brian was here. Briefly.")?; - /// - /// // `tmp_dir` goes out of scope, the directory as well as - /// // `tmp_file` will be deleted here. - /// # Ok(()) - /// # } - /// ``` - /// - /// [`Builder`]: struct.Builder.html - pub fn new() -> io::Result<TempDir> { - Builder::new().tempdir() - } - - /// Attempts to make a temporary directory inside of `dir`. - /// The directory and everything inside it will be automatically - /// deleted once the returned `TempDir` is destroyed. - /// - /// # Errors - /// - /// If the directory can not be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// use std::fs::{self, File}; - /// use std::io::Write; - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// // Create a directory inside of the current directory - /// let tmp_dir = TempDir::new_in(".")?; - /// let file_path = tmp_dir.path().join("my-temporary-note.txt"); - /// let mut tmp_file = File::create(file_path)?; - /// writeln!(tmp_file, "Brian was here. Briefly.")?; - /// # Ok(()) - /// # } - /// ``` - pub fn new_in<P: AsRef<Path>>(dir: P) -> io::Result<TempDir> { - Builder::new().tempdir_in(dir) - } - - /// Attempts to make a temporary directory with the specified prefix inside of - /// `env::temp_dir()`. The directory and everything inside it will be automatically - /// deleted once the returned `TempDir` is destroyed. - /// - /// # Errors - /// - /// If the directory can not be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// use std::fs::{self, File}; - /// use std::io::Write; - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// // Create a directory inside of the current directory - /// let tmp_dir = TempDir::with_prefix("foo-")?; - /// let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap(); - /// assert!(tmp_name.starts_with("foo-")); - /// # Ok(()) - /// # } - /// ``` - pub fn with_prefix<S: AsRef<OsStr>>(prefix: S) -> io::Result<TempDir> { - Builder::new().prefix(&prefix).tempdir() - } - - /// Attempts to make a temporary directory with the specified prefix inside - /// the specified directory. The directory and everything inside it will be - /// automatically deleted once the returned `TempDir` is destroyed. - /// - /// # Errors - /// - /// If the directory can not be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// use std::fs::{self, File}; - /// use std::io::Write; - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// // Create a directory inside of the current directory - /// let tmp_dir = TempDir::with_prefix_in("foo-", ".")?; - /// let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap(); - /// assert!(tmp_name.starts_with("foo-")); - /// # Ok(()) - /// # } - /// ``` - pub fn with_prefix_in<S: AsRef<OsStr>, P: AsRef<Path>>( - prefix: S, - dir: P, - ) -> io::Result<TempDir> { - Builder::new().prefix(&prefix).tempdir_in(dir) - } - - /// Accesses the [`Path`] to the temporary directory. - /// - /// [`Path`]: http://doc.rust-lang.org/std/path/struct.Path.html - /// - /// # Examples - /// - /// ``` - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// let tmp_path; - /// - /// { - /// let tmp_dir = TempDir::new()?; - /// tmp_path = tmp_dir.path().to_owned(); - /// - /// // Check that the temp directory actually exists. - /// assert!(tmp_path.exists()); - /// - /// // End of `tmp_dir` scope, directory will be deleted - /// } - /// - /// // Temp directory should be deleted by now - /// assert_eq!(tmp_path.exists(), false); - /// # Ok(()) - /// # } - /// ``` - #[must_use] - pub fn path(&self) -> &path::Path { - self.path.as_ref() - } - - /// Persist the temporary directory to disk, returning the [`PathBuf`] where it is located. - /// - /// This consumes the [`TempDir`] without deleting directory on the filesystem, meaning that - /// the directory will no longer be automatically deleted. - /// - /// [`TempDir`]: struct.TempDir.html - /// [`PathBuf`]: http://doc.rust-lang.org/std/path/struct.PathBuf.html - /// - /// # Examples - /// - /// ``` - /// use std::fs; - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// let tmp_dir = TempDir::new()?; - /// - /// // Persist the temporary directory to disk, - /// // getting the path where it is. - /// let tmp_path = tmp_dir.into_path(); - /// - /// // Delete the temporary directory ourselves. - /// fs::remove_dir_all(tmp_path)?; - /// # Ok(()) - /// # } - /// ``` - #[must_use] - pub fn into_path(self) -> PathBuf { - // Prevent the Drop impl from being called. - let mut this = mem::ManuallyDrop::new(self); - - // replace this.path with an empty Box, since an empty Box does not - // allocate any heap memory. - mem::replace(&mut this.path, PathBuf::new().into_boxed_path()).into() - } - - /// Closes and removes the temporary directory, returning a `Result`. - /// - /// Although `TempDir` removes the directory on drop, in the destructor - /// any errors are ignored. To detect errors cleaning up the temporary - /// directory, call `close` instead. - /// - /// # Errors - /// - /// This function may return a variety of [`std::io::Error`]s that result from deleting - /// the files and directories contained with the temporary directory, - /// as well as from deleting the temporary directory itself. These errors - /// may be platform specific. - /// - /// [`std::io::Error`]: http://doc.rust-lang.org/std/io/struct.Error.html - /// - /// # Examples - /// - /// ``` - /// use std::fs::File; - /// use std::io::Write; - /// use tempfile::TempDir; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// // Create a directory inside of `std::env::temp_dir()`. - /// let tmp_dir = TempDir::new()?; - /// let file_path = tmp_dir.path().join("my-temporary-note.txt"); - /// let mut tmp_file = File::create(file_path)?; - /// writeln!(tmp_file, "Brian was here. Briefly.")?; - /// - /// // By closing the `TempDir` explicitly we can check that it has - /// // been deleted successfully. If we don't close it explicitly, - /// // the directory will still be deleted when `tmp_dir` goes out - /// // of scope, but we won't know whether deleting the directory - /// // succeeded. - /// drop(tmp_file); - /// tmp_dir.close()?; - /// # Ok(()) - /// # } - /// ``` - pub fn close(mut self) -> io::Result<()> { - let result = remove_dir_all(self.path()).with_err_path(|| self.path()); - - // Set self.path to empty Box to release the memory, since an empty - // Box does not allocate any heap memory. - self.path = PathBuf::new().into_boxed_path(); - - // Prevent the Drop impl from being called. - mem::forget(self); - - result - } -} - -impl AsRef<Path> for TempDir { - fn as_ref(&self) -> &Path { - self.path() - } -} - -impl fmt::Debug for TempDir { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("TempDir") - .field("path", &self.path()) - .finish() - } -} - -impl Drop for TempDir { - fn drop(&mut self) { - let _ = remove_dir_all(self.path()); - } -} - -pub(crate) fn create(path: PathBuf) -> io::Result<TempDir> { - fs::create_dir(&path) - .with_err_path(|| &path) - .map(|_| TempDir { - path: path.into_boxed_path(), - }) -} diff --git a/vendor/tempfile/src/error.rs b/vendor/tempfile/src/error.rs deleted file mode 100644 index ed6b6cc..0000000 --- a/vendor/tempfile/src/error.rs +++ /dev/null @@ -1,45 +0,0 @@ -use std::path::PathBuf; -use std::{error, fmt, io}; - -#[derive(Debug)] -struct PathError { - path: PathBuf, - err: io::Error, -} - -impl fmt::Display for PathError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{} at path {:?}", self.err, self.path) - } -} - -impl error::Error for PathError { - fn source(&self) -> Option<&(dyn error::Error + 'static)> { - self.err.source() - } -} - -pub(crate) trait IoResultExt<T> { - fn with_err_path<F, P>(self, path: F) -> Self - where - F: FnOnce() -> P, - P: Into<PathBuf>; -} - -impl<T> IoResultExt<T> for Result<T, io::Error> { - fn with_err_path<F, P>(self, path: F) -> Self - where - F: FnOnce() -> P, - P: Into<PathBuf>, - { - self.map_err(|e| { - io::Error::new( - e.kind(), - PathError { - path: path().into(), - err: e, - }, - ) - }) - } -} diff --git a/vendor/tempfile/src/file/imp/mod.rs b/vendor/tempfile/src/file/imp/mod.rs deleted file mode 100644 index fbb2bbf..0000000 --- a/vendor/tempfile/src/file/imp/mod.rs +++ /dev/null @@ -1,12 +0,0 @@ -cfg_if::cfg_if! { - if #[cfg(any(unix, target_os = "redox", target_os = "wasi"))] { - mod unix; - pub use self::unix::*; - } else if #[cfg(windows)] { - mod windows; - pub use self::windows::*; - } else { - mod other; - pub use self::other::*; - } -} diff --git a/vendor/tempfile/src/file/imp/other.rs b/vendor/tempfile/src/file/imp/other.rs deleted file mode 100644 index 8721d2d..0000000 --- a/vendor/tempfile/src/file/imp/other.rs +++ /dev/null @@ -1,30 +0,0 @@ -use std::fs::{File, OpenOptions}; -use std::io; -use std::path::Path; - -fn not_supported<T>() -> io::Result<T> { - Err(io::Error::new( - io::ErrorKind::Other, - "operation not supported on this platform", - )) -} - -pub fn create_named(_path: &Path, _open_options: &mut OpenOptions) -> io::Result<File> { - not_supported() -} - -pub fn create(_dir: &Path) -> io::Result<File> { - not_supported() -} - -pub fn reopen(_file: &File, _path: &Path) -> io::Result<File> { - not_supported() -} - -pub fn persist(_old_path: &Path, _new_path: &Path, _overwrite: bool) -> io::Result<()> { - not_supported() -} - -pub fn keep(_path: &Path) -> io::Result<()> { - not_supported() -} diff --git a/vendor/tempfile/src/file/imp/unix.rs b/vendor/tempfile/src/file/imp/unix.rs deleted file mode 100644 index 79aba78..0000000 --- a/vendor/tempfile/src/file/imp/unix.rs +++ /dev/null @@ -1,149 +0,0 @@ -use std::env; -use std::ffi::OsStr; -use std::fs::{self, File, OpenOptions}; -use std::io; -cfg_if::cfg_if! { - if #[cfg(not(target_os = "wasi"))] { - use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; - } else { - #[cfg(feature = "nightly")] - use std::os::wasi::fs::MetadataExt; - } -} -use crate::util; -use std::path::Path; - -#[cfg(not(target_os = "redox"))] -use { - rustix::fs::{rename, unlink}, - std::fs::hard_link, -}; - -pub fn create_named(path: &Path, open_options: &mut OpenOptions) -> io::Result<File> { - open_options.read(true).write(true).create_new(true); - - #[cfg(not(target_os = "wasi"))] - { - open_options.mode(0o600); - } - - open_options.open(path) -} - -fn create_unlinked(path: &Path) -> io::Result<File> { - let tmp; - // shadow this to decrease the lifetime. It can't live longer than `tmp`. - let mut path = path; - if !path.is_absolute() { - let cur_dir = env::current_dir()?; - tmp = cur_dir.join(path); - path = &tmp; - } - - let f = create_named(path, &mut OpenOptions::new())?; - // don't care whether the path has already been unlinked, - // but perhaps there are some IO error conditions we should send up? - let _ = fs::remove_file(path); - Ok(f) -} - -#[cfg(target_os = "linux")] -pub fn create(dir: &Path) -> io::Result<File> { - use rustix::{fs::OFlags, io::Errno}; - OpenOptions::new() - .read(true) - .write(true) - .custom_flags(OFlags::TMPFILE.bits() as i32) // do not mix with `create_new(true)` - .open(dir) - .or_else(|e| { - match Errno::from_io_error(&e) { - // These are the three "not supported" error codes for O_TMPFILE. - Some(Errno::OPNOTSUPP) | Some(Errno::ISDIR) | Some(Errno::NOENT) => { - create_unix(dir) - } - _ => Err(e), - } - }) -} - -#[cfg(not(target_os = "linux"))] -pub fn create(dir: &Path) -> io::Result<File> { - create_unix(dir) -} - -fn create_unix(dir: &Path) -> io::Result<File> { - util::create_helper( - dir, - OsStr::new(".tmp"), - OsStr::new(""), - crate::NUM_RAND_CHARS, - |path| create_unlinked(&path), - ) -} - -#[cfg(any(not(target_os = "wasi"), feature = "nightly"))] -pub fn reopen(file: &File, path: &Path) -> io::Result<File> { - let new_file = OpenOptions::new().read(true).write(true).open(path)?; - let old_meta = file.metadata()?; - let new_meta = new_file.metadata()?; - if old_meta.dev() != new_meta.dev() || old_meta.ino() != new_meta.ino() { - return Err(io::Error::new( - io::ErrorKind::NotFound, - "original tempfile has been replaced", - )); - } - Ok(new_file) -} - -#[cfg(all(target_os = "wasi", not(feature = "nightly")))] -pub fn reopen(_file: &File, _path: &Path) -> io::Result<File> { - return Err(io::Error::new( - io::ErrorKind::Other, - "this operation is supported on WASI only on nightly Rust (with `nightly` feature enabled)", - )); -} - -#[cfg(not(target_os = "redox"))] -pub fn persist(old_path: &Path, new_path: &Path, overwrite: bool) -> io::Result<()> { - if overwrite { - rename(old_path, new_path)?; - } else { - // On Linux, use `renameat_with` to avoid overwriting an existing name, - // if the kernel and the filesystem support it. - #[cfg(any(target_os = "android", target_os = "linux"))] - { - use rustix::fs::{renameat_with, RenameFlags, CWD}; - use rustix::io::Errno; - use std::sync::atomic::{AtomicBool, Ordering::Relaxed}; - - static NOSYS: AtomicBool = AtomicBool::new(false); - if !NOSYS.load(Relaxed) { - match renameat_with(CWD, old_path, CWD, new_path, RenameFlags::NOREPLACE) { - Ok(()) => return Ok(()), - Err(Errno::NOSYS) => NOSYS.store(true, Relaxed), - Err(Errno::INVAL) => {} - Err(e) => return Err(e.into()), - } - } - } - - // Otherwise use `hard_link` to create the new filesystem name, which - // will fail if the name already exists, and then `unlink` to remove - // the old name. - hard_link(old_path, new_path)?; - - // Ignore unlink errors. Can we do better? - let _ = unlink(old_path); - } - Ok(()) -} - -#[cfg(target_os = "redox")] -pub fn persist(_old_path: &Path, _new_path: &Path, _overwrite: bool) -> io::Result<()> { - // XXX implement when possible - Err(io::Error::from_raw_os_error(syscall::ENOSYS)) -} - -pub fn keep(_: &Path) -> io::Result<()> { - Ok(()) -} diff --git a/vendor/tempfile/src/file/imp/windows.rs b/vendor/tempfile/src/file/imp/windows.rs deleted file mode 100644 index 9df65f9..0000000 --- a/vendor/tempfile/src/file/imp/windows.rs +++ /dev/null @@ -1,104 +0,0 @@ -use std::ffi::OsStr; -use std::fs::{File, OpenOptions}; -use std::os::windows::ffi::OsStrExt; -use std::os::windows::fs::OpenOptionsExt; -use std::os::windows::io::{AsRawHandle, FromRawHandle, RawHandle}; -use std::path::Path; -use std::{io, iter}; - -use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE}; -use windows_sys::Win32::Storage::FileSystem::{ - MoveFileExW, ReOpenFile, SetFileAttributesW, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_TEMPORARY, - FILE_FLAG_DELETE_ON_CLOSE, FILE_GENERIC_READ, FILE_GENERIC_WRITE, FILE_SHARE_DELETE, - FILE_SHARE_READ, FILE_SHARE_WRITE, MOVEFILE_REPLACE_EXISTING, -}; - -use crate::util; - -fn to_utf16(s: &Path) -> Vec<u16> { - s.as_os_str().encode_wide().chain(iter::once(0)).collect() -} - -pub fn create_named(path: &Path, open_options: &mut OpenOptions) -> io::Result<File> { - open_options - .create_new(true) - .read(true) - .write(true) - .custom_flags(FILE_ATTRIBUTE_TEMPORARY) - .open(path) -} - -pub fn create(dir: &Path) -> io::Result<File> { - util::create_helper( - dir, - OsStr::new(".tmp"), - OsStr::new(""), - crate::NUM_RAND_CHARS, - |path| { - OpenOptions::new() - .create_new(true) - .read(true) - .write(true) - .share_mode(0) - .custom_flags(FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE) - .open(path) - }, - ) -} - -pub fn reopen(file: &File, _path: &Path) -> io::Result<File> { - let handle = file.as_raw_handle(); - unsafe { - let handle = ReOpenFile( - handle as HANDLE, - FILE_GENERIC_READ | FILE_GENERIC_WRITE, - FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, - 0, - ); - if handle == INVALID_HANDLE_VALUE { - Err(io::Error::last_os_error()) - } else { - Ok(FromRawHandle::from_raw_handle(handle as RawHandle)) - } - } -} - -pub fn keep(path: &Path) -> io::Result<()> { - unsafe { - let path_w = to_utf16(path); - if SetFileAttributesW(path_w.as_ptr(), FILE_ATTRIBUTE_NORMAL) == 0 { - Err(io::Error::last_os_error()) - } else { - Ok(()) - } - } -} - -pub fn persist(old_path: &Path, new_path: &Path, overwrite: bool) -> io::Result<()> { - unsafe { - let old_path_w = to_utf16(old_path); - let new_path_w = to_utf16(new_path); - - // Don't succeed if this fails. We don't want to claim to have successfully persisted a file - // still marked as temporary because this file won't have the same consistency guarantees. - if SetFileAttributesW(old_path_w.as_ptr(), FILE_ATTRIBUTE_NORMAL) == 0 { - return Err(io::Error::last_os_error()); - } - - let mut flags = 0; - - if overwrite { - flags |= MOVEFILE_REPLACE_EXISTING; - } - - if MoveFileExW(old_path_w.as_ptr(), new_path_w.as_ptr(), flags) == 0 { - let e = io::Error::last_os_error(); - // If this fails, the temporary file is now un-hidden and no longer marked temporary - // (slightly less efficient) but it will still work. - let _ = SetFileAttributesW(old_path_w.as_ptr(), FILE_ATTRIBUTE_TEMPORARY); - Err(e) - } else { - Ok(()) - } - } -} diff --git a/vendor/tempfile/src/file/mod.rs b/vendor/tempfile/src/file/mod.rs deleted file mode 100644 index 8a28343..0000000 --- a/vendor/tempfile/src/file/mod.rs +++ /dev/null @@ -1,1124 +0,0 @@ -use std::env; -use std::error; -use std::ffi::OsStr; -use std::fmt; -use std::fs::{self, File, OpenOptions}; -use std::io::{self, Read, Seek, SeekFrom, Write}; -use std::mem; -use std::ops::Deref; -#[cfg(unix)] -use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd}; -#[cfg(target_os = "wasi")] -use std::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, RawFd}; -#[cfg(windows)] -use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle, RawHandle}; -use std::path::{Path, PathBuf}; - -use crate::error::IoResultExt; -use crate::Builder; - -mod imp; - -/// Create a new temporary file. -/// -/// The file will be created in the location returned by [`std::env::temp_dir()`]. -/// -/// # Security -/// -/// This variant is secure/reliable in the presence of a pathological temporary file cleaner. -/// -/// # Resource Leaking -/// -/// The temporary file will be automatically removed by the OS when the last handle to it is closed. -/// This doesn't rely on Rust destructors being run, so will (almost) never fail to clean up the temporary file. -/// -/// # Errors -/// -/// If the file can not be created, `Err` is returned. -/// -/// # Examples -/// -/// ``` -/// use tempfile::tempfile; -/// use std::io::{self, Write}; -/// -/// # fn main() { -/// # if let Err(_) = run() { -/// # ::std::process::exit(1); -/// # } -/// # } -/// # fn run() -> Result<(), io::Error> { -/// // Create a file inside of `std::env::temp_dir()`. -/// let mut file = tempfile()?; -/// -/// writeln!(file, "Brian was here. Briefly.")?; -/// # Ok(()) -/// # } -/// ``` -/// -/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html -pub fn tempfile() -> io::Result<File> { - tempfile_in(env::temp_dir()) -} - -/// Create a new temporary file in the specified directory. -/// -/// # Security -/// -/// This variant is secure/reliable in the presence of a pathological temporary file cleaner. -/// If the temporary file isn't created in [`std::env::temp_dir()`] then temporary file cleaners aren't an issue. -/// -/// # Resource Leaking -/// -/// The temporary file will be automatically removed by the OS when the last handle to it is closed. -/// This doesn't rely on Rust destructors being run, so will (almost) never fail to clean up the temporary file. -/// -/// # Errors -/// -/// If the file can not be created, `Err` is returned. -/// -/// # Examples -/// -/// ``` -/// use tempfile::tempfile_in; -/// use std::io::{self, Write}; -/// -/// # fn main() { -/// # if let Err(_) = run() { -/// # ::std::process::exit(1); -/// # } -/// # } -/// # fn run() -> Result<(), io::Error> { -/// // Create a file inside of the current working directory -/// let mut file = tempfile_in("./")?; -/// -/// writeln!(file, "Brian was here. Briefly.")?; -/// # Ok(()) -/// # } -/// ``` -/// -/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html -pub fn tempfile_in<P: AsRef<Path>>(dir: P) -> io::Result<File> { - imp::create(dir.as_ref()) -} - -/// Error returned when persisting a temporary file path fails. -#[derive(Debug)] -pub struct PathPersistError { - /// The underlying IO error. - pub error: io::Error, - /// The temporary file path that couldn't be persisted. - pub path: TempPath, -} - -impl From<PathPersistError> for io::Error { - #[inline] - fn from(error: PathPersistError) -> io::Error { - error.error - } -} - -impl From<PathPersistError> for TempPath { - #[inline] - fn from(error: PathPersistError) -> TempPath { - error.path - } -} - -impl fmt::Display for PathPersistError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "failed to persist temporary file path: {}", self.error) - } -} - -impl error::Error for PathPersistError { - fn source(&self) -> Option<&(dyn error::Error + 'static)> { - Some(&self.error) - } -} - -/// A path to a named temporary file without an open file handle. -/// -/// This is useful when the temporary file needs to be used by a child process, -/// for example. -/// -/// When dropped, the temporary file is deleted. -pub struct TempPath { - path: Box<Path>, -} - -impl TempPath { - /// Close and remove the temporary file. - /// - /// Use this if you want to detect errors in deleting the file. - /// - /// # Errors - /// - /// If the file cannot be deleted, `Err` is returned. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let file = NamedTempFile::new()?; - /// - /// // Close the file, but keep the path to it around. - /// let path = file.into_temp_path(); - /// - /// // By closing the `TempPath` explicitly, we can check that it has - /// // been deleted successfully. If we don't close it explicitly, the - /// // file will still be deleted when `file` goes out of scope, but we - /// // won't know whether deleting the file succeeded. - /// path.close()?; - /// # Ok(()) - /// # } - /// ``` - pub fn close(mut self) -> io::Result<()> { - let result = fs::remove_file(&self.path).with_err_path(|| &*self.path); - self.path = PathBuf::new().into_boxed_path(); - mem::forget(self); - result - } - - /// Persist the temporary file at the target path. - /// - /// If a file exists at the target path, persist will atomically replace it. - /// If this method fails, it will return `self` in the resulting - /// [`PathPersistError`]. - /// - /// Note: Temporary files cannot be persisted across filesystems. Also - /// neither the file contents nor the containing directory are - /// synchronized, so the update may not yet have reached the disk when - /// `persist` returns. - /// - /// # Security - /// - /// Only use this method if you're positive that a temporary file cleaner - /// won't have deleted your file. Otherwise, you might end up persisting an - /// attacker controlled file. - /// - /// # Errors - /// - /// If the file cannot be moved to the new location, `Err` is returned. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let mut file = NamedTempFile::new()?; - /// writeln!(file, "Brian was here. Briefly.")?; - /// - /// let path = file.into_temp_path(); - /// path.persist("./saved_file.txt")?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [`PathPersistError`]: struct.PathPersistError.html - pub fn persist<P: AsRef<Path>>(mut self, new_path: P) -> Result<(), PathPersistError> { - match imp::persist(&self.path, new_path.as_ref(), true) { - Ok(_) => { - // Don't drop `self`. We don't want to try deleting the old - // temporary file path. (It'll fail, but the failure is never - // seen.) - self.path = PathBuf::new().into_boxed_path(); - mem::forget(self); - Ok(()) - } - Err(e) => Err(PathPersistError { - error: e, - path: self, - }), - } - } - - /// Persist the temporary file at the target path if and only if no file exists there. - /// - /// If a file exists at the target path, fail. If this method fails, it will - /// return `self` in the resulting [`PathPersistError`]. - /// - /// Note: Temporary files cannot be persisted across filesystems. Also Note: - /// This method is not atomic. It can leave the original link to the - /// temporary file behind. - /// - /// # Security - /// - /// Only use this method if you're positive that a temporary file cleaner - /// won't have deleted your file. Otherwise, you might end up persisting an - /// attacker controlled file. - /// - /// # Errors - /// - /// If the file cannot be moved to the new location or a file already exists - /// there, `Err` is returned. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let mut file = NamedTempFile::new()?; - /// writeln!(file, "Brian was here. Briefly.")?; - /// - /// let path = file.into_temp_path(); - /// path.persist_noclobber("./saved_file.txt")?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [`PathPersistError`]: struct.PathPersistError.html - pub fn persist_noclobber<P: AsRef<Path>>( - mut self, - new_path: P, - ) -> Result<(), PathPersistError> { - match imp::persist(&self.path, new_path.as_ref(), false) { - Ok(_) => { - // Don't drop `self`. We don't want to try deleting the old - // temporary file path. (It'll fail, but the failure is never - // seen.) - self.path = PathBuf::new().into_boxed_path(); - mem::forget(self); - Ok(()) - } - Err(e) => Err(PathPersistError { - error: e, - path: self, - }), - } - } - - /// Keep the temporary file from being deleted. This function will turn the - /// temporary file into a non-temporary file without moving it. - /// - /// - /// # Errors - /// - /// On some platforms (e.g., Windows), we need to mark the file as - /// non-temporary. This operation could fail. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let mut file = NamedTempFile::new()?; - /// writeln!(file, "Brian was here. Briefly.")?; - /// - /// let path = file.into_temp_path(); - /// let path = path.keep()?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [`PathPersistError`]: struct.PathPersistError.html - pub fn keep(mut self) -> Result<PathBuf, PathPersistError> { - match imp::keep(&self.path) { - Ok(_) => { - // Don't drop `self`. We don't want to try deleting the old - // temporary file path. (It'll fail, but the failure is never - // seen.) - let path = mem::replace(&mut self.path, PathBuf::new().into_boxed_path()); - mem::forget(self); - Ok(path.into()) - } - Err(e) => Err(PathPersistError { - error: e, - path: self, - }), - } - } - - /// Create a new TempPath from an existing path. This can be done even if no - /// file exists at the given path. - /// - /// This is mostly useful for interacting with libraries and external - /// components that provide files to be consumed or expect a path with no - /// existing file to be given. - pub fn from_path(path: impl Into<PathBuf>) -> Self { - Self { - path: path.into().into_boxed_path(), - } - } -} - -impl fmt::Debug for TempPath { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - self.path.fmt(f) - } -} - -impl Drop for TempPath { - fn drop(&mut self) { - let _ = fs::remove_file(&self.path); - } -} - -impl Deref for TempPath { - type Target = Path; - - fn deref(&self) -> &Path { - &self.path - } -} - -impl AsRef<Path> for TempPath { - fn as_ref(&self) -> &Path { - &self.path - } -} - -impl AsRef<OsStr> for TempPath { - fn as_ref(&self) -> &OsStr { - self.path.as_os_str() - } -} - -/// A named temporary file. -/// -/// The default constructor, [`NamedTempFile::new()`], creates files in -/// the location returned by [`std::env::temp_dir()`], but `NamedTempFile` -/// can be configured to manage a temporary file in any location -/// by constructing with [`NamedTempFile::new_in()`]. -/// -/// # Security -/// -/// Most operating systems employ temporary file cleaners to delete old -/// temporary files. Unfortunately these temporary file cleaners don't always -/// reliably _detect_ whether the temporary file is still being used. -/// -/// Specifically, the following sequence of events can happen: -/// -/// 1. A user creates a temporary file with `NamedTempFile::new()`. -/// 2. Time passes. -/// 3. The temporary file cleaner deletes (unlinks) the temporary file from the -/// filesystem. -/// 4. Some other program creates a new file to replace this deleted temporary -/// file. -/// 5. The user tries to re-open the temporary file (in the same program or in a -/// different program) by path. Unfortunately, they'll end up opening the -/// file created by the other program, not the original file. -/// -/// ## Operating System Specific Concerns -/// -/// The behavior of temporary files and temporary file cleaners differ by -/// operating system. -/// -/// ### Windows -/// -/// On Windows, open files _can't_ be deleted. This removes most of the concerns -/// around temporary file cleaners. -/// -/// Furthermore, temporary files are, by default, created in per-user temporary -/// file directories so only an application running as the same user would be -/// able to interfere (which they could do anyways). However, an application -/// running as the same user can still _accidentally_ re-create deleted -/// temporary files if the number of random bytes in the temporary file name is -/// too small. -/// -/// So, the only real concern on Windows is: -/// -/// 1. Opening a named temporary file in a world-writable directory. -/// 2. Using the `into_temp_path()` and/or `into_parts()` APIs to close the file -/// handle without deleting the underlying file. -/// 3. Continuing to use the file by path. -/// -/// ### UNIX -/// -/// Unlike on Windows, UNIX (and UNIX like) systems allow open files to be -/// "unlinked" (deleted). -/// -/// #### MacOS -/// -/// Like on Windows, temporary files are created in per-user temporary file -/// directories by default so calling `NamedTempFile::new()` should be -/// relatively safe. -/// -/// #### Linux -/// -/// Unfortunately, most _Linux_ distributions don't create per-user temporary -/// file directories. Worse, systemd's tmpfiles daemon (a common temporary file -/// cleaner) will happily remove open temporary files if they haven't been -/// modified within the last 10 days. -/// -/// # Resource Leaking -/// -/// If the program exits before the `NamedTempFile` destructor is -/// run, the temporary file will not be deleted. This can happen -/// if the process exits using [`std::process::exit()`], a segfault occurs, -/// receiving an interrupt signal like `SIGINT` that is not handled, or by using -/// a statically declared `NamedTempFile` instance (like with [`lazy_static`]). -/// -/// Use the [`tempfile()`] function unless you need a named file path. -/// -/// [`tempfile()`]: fn.tempfile.html -/// [`NamedTempFile::new()`]: #method.new -/// [`NamedTempFile::new_in()`]: #method.new_in -/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html -/// [`std::process::exit()`]: http://doc.rust-lang.org/std/process/fn.exit.html -/// [`lazy_static`]: https://github.com/rust-lang-nursery/lazy-static.rs/issues/62 -pub struct NamedTempFile<F = File> { - path: TempPath, - file: F, -} - -impl<F> fmt::Debug for NamedTempFile<F> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "NamedTempFile({:?})", self.path) - } -} - -impl<F> AsRef<Path> for NamedTempFile<F> { - #[inline] - fn as_ref(&self) -> &Path { - self.path() - } -} - -/// Error returned when persisting a temporary file fails. -pub struct PersistError<F = File> { - /// The underlying IO error. - pub error: io::Error, - /// The temporary file that couldn't be persisted. - pub file: NamedTempFile<F>, -} - -impl<F> fmt::Debug for PersistError<F> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "PersistError({:?})", self.error) - } -} - -impl<F> From<PersistError<F>> for io::Error { - #[inline] - fn from(error: PersistError<F>) -> io::Error { - error.error - } -} - -impl<F> From<PersistError<F>> for NamedTempFile<F> { - #[inline] - fn from(error: PersistError<F>) -> NamedTempFile<F> { - error.file - } -} - -impl<F> fmt::Display for PersistError<F> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "failed to persist temporary file: {}", self.error) - } -} - -impl<F> error::Error for PersistError<F> { - fn source(&self) -> Option<&(dyn error::Error + 'static)> { - Some(&self.error) - } -} - -impl NamedTempFile<File> { - /// Create a new named temporary file. - /// - /// See [`Builder`] for more configuration. - /// - /// # Security - /// - /// This will create a temporary file in the default temporary file - /// directory (platform dependent). This has security implications on many - /// platforms so please read the security section of this type's - /// documentation. - /// - /// Reasons to use this method: - /// - /// 1. The file has a short lifetime and your temporary file cleaner is - /// sane (doesn't delete recently accessed files). - /// - /// 2. You trust every user on your system (i.e. you are the only user). - /// - /// 3. You have disabled your system's temporary file cleaner or verified - /// that your system doesn't have a temporary file cleaner. - /// - /// Reasons not to use this method: - /// - /// 1. You'll fix it later. No you won't. - /// - /// 2. You don't care about the security of the temporary file. If none of - /// the "reasons to use this method" apply, referring to a temporary - /// file by name may allow an attacker to create/overwrite your - /// non-temporary files. There are exceptions but if you don't already - /// know them, don't use this method. - /// - /// # Errors - /// - /// If the file can not be created, `Err` is returned. - /// - /// # Examples - /// - /// Create a named temporary file and write some data to it: - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), ::std::io::Error> { - /// let mut file = NamedTempFile::new()?; - /// - /// writeln!(file, "Brian was here. Briefly.")?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [`Builder`]: struct.Builder.html - pub fn new() -> io::Result<NamedTempFile> { - Builder::new().tempfile() - } - - /// Create a new named temporary file in the specified directory. - /// - /// This is equivalent to: - /// - /// ```ignore - /// Builder::new().tempfile_in(dir) - /// ``` - /// - /// See [`NamedTempFile::new()`] for details. - /// - /// [`NamedTempFile::new()`]: #method.new - pub fn new_in<P: AsRef<Path>>(dir: P) -> io::Result<NamedTempFile> { - Builder::new().tempfile_in(dir) - } - - /// Create a new named temporary file with the specified filename prefix. - /// - /// See [`NamedTempFile::new()`] for details. - /// - /// [`NamedTempFile::new()`]: #method.new - pub fn with_prefix<S: AsRef<OsStr>>(prefix: S) -> io::Result<NamedTempFile> { - Builder::new().prefix(&prefix).tempfile() - } - /// Create a new named temporary file with the specified filename prefix, - /// in the specified directory. - /// - /// This is equivalent to: - /// - /// ```ignore - /// Builder::new().prefix(&prefix).tempfile_in(directory) - /// ``` - /// - /// See [`NamedTempFile::new()`] for details. - /// - /// [`NamedTempFile::new()`]: #method.new - pub fn with_prefix_in<S: AsRef<OsStr>, P: AsRef<Path>>( - prefix: S, - dir: P, - ) -> io::Result<NamedTempFile> { - Builder::new().prefix(&prefix).tempfile_in(dir) - } -} - -impl<F> NamedTempFile<F> { - /// Get the temporary file's path. - /// - /// # Security - /// - /// Referring to a temporary file's path may not be secure in all cases. - /// Please read the security section on the top level documentation of this - /// type for details. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), ::std::io::Error> { - /// let file = NamedTempFile::new()?; - /// - /// println!("{:?}", file.path()); - /// # Ok(()) - /// # } - /// ``` - #[inline] - pub fn path(&self) -> &Path { - &self.path - } - - /// Close and remove the temporary file. - /// - /// Use this if you want to detect errors in deleting the file. - /// - /// # Errors - /// - /// If the file cannot be deleted, `Err` is returned. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let file = NamedTempFile::new()?; - /// - /// // By closing the `NamedTempFile` explicitly, we can check that it has - /// // been deleted successfully. If we don't close it explicitly, - /// // the file will still be deleted when `file` goes out - /// // of scope, but we won't know whether deleting the file - /// // succeeded. - /// file.close()?; - /// # Ok(()) - /// # } - /// ``` - pub fn close(self) -> io::Result<()> { - let NamedTempFile { path, .. } = self; - path.close() - } - - /// Persist the temporary file at the target path. - /// - /// If a file exists at the target path, persist will atomically replace it. - /// If this method fails, it will return `self` in the resulting - /// [`PersistError`]. - /// - /// Note: Temporary files cannot be persisted across filesystems. Also - /// neither the file contents nor the containing directory are - /// synchronized, so the update may not yet have reached the disk when - /// `persist` returns. - /// - /// # Security - /// - /// This method persists the temporary file using its path and may not be - /// secure in all cases. Please read the security section on the top - /// level documentation of this type for details. - /// - /// # Errors - /// - /// If the file cannot be moved to the new location, `Err` is returned. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let file = NamedTempFile::new()?; - /// - /// let mut persisted_file = file.persist("./saved_file.txt")?; - /// writeln!(persisted_file, "Brian was here. Briefly.")?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [`PersistError`]: struct.PersistError.html - pub fn persist<P: AsRef<Path>>(self, new_path: P) -> Result<F, PersistError<F>> { - let NamedTempFile { path, file } = self; - match path.persist(new_path) { - Ok(_) => Ok(file), - Err(err) => { - let PathPersistError { error, path } = err; - Err(PersistError { - file: NamedTempFile { path, file }, - error, - }) - } - } - } - - /// Persist the temporary file at the target path if and only if no file exists there. - /// - /// If a file exists at the target path, fail. If this method fails, it will - /// return `self` in the resulting PersistError. - /// - /// Note: Temporary files cannot be persisted across filesystems. Also Note: - /// This method is not atomic. It can leave the original link to the - /// temporary file behind. - /// - /// # Security - /// - /// This method persists the temporary file using its path and may not be - /// secure in all cases. Please read the security section on the top - /// level documentation of this type for details. - /// - /// # Errors - /// - /// If the file cannot be moved to the new location or a file already exists there, - /// `Err` is returned. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let file = NamedTempFile::new()?; - /// - /// let mut persisted_file = file.persist_noclobber("./saved_file.txt")?; - /// writeln!(persisted_file, "Brian was here. Briefly.")?; - /// # Ok(()) - /// # } - /// ``` - pub fn persist_noclobber<P: AsRef<Path>>(self, new_path: P) -> Result<F, PersistError<F>> { - let NamedTempFile { path, file } = self; - match path.persist_noclobber(new_path) { - Ok(_) => Ok(file), - Err(err) => { - let PathPersistError { error, path } = err; - Err(PersistError { - file: NamedTempFile { path, file }, - error, - }) - } - } - } - - /// Keep the temporary file from being deleted. This function will turn the - /// temporary file into a non-temporary file without moving it. - /// - /// - /// # Errors - /// - /// On some platforms (e.g., Windows), we need to mark the file as - /// non-temporary. This operation could fail. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io::{self, Write}; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let mut file = NamedTempFile::new()?; - /// writeln!(file, "Brian was here. Briefly.")?; - /// - /// let (file, path) = file.keep()?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [`PathPersistError`]: struct.PathPersistError.html - pub fn keep(self) -> Result<(F, PathBuf), PersistError<F>> { - let (file, path) = (self.file, self.path); - match path.keep() { - Ok(path) => Ok((file, path)), - Err(PathPersistError { error, path }) => Err(PersistError { - file: NamedTempFile { path, file }, - error, - }), - } - } - - /// Get a reference to the underlying file. - pub fn as_file(&self) -> &F { - &self.file - } - - /// Get a mutable reference to the underlying file. - pub fn as_file_mut(&mut self) -> &mut F { - &mut self.file - } - - /// Convert the temporary file into a `std::fs::File`. - /// - /// The inner file will be deleted. - pub fn into_file(self) -> F { - self.file - } - - /// Closes the file, leaving only the temporary file path. - /// - /// This is useful when another process must be able to open the temporary - /// file. - pub fn into_temp_path(self) -> TempPath { - self.path - } - - /// Converts the named temporary file into its constituent parts. - /// - /// Note: When the path is dropped, the file is deleted but the file handle - /// is still usable. - pub fn into_parts(self) -> (F, TempPath) { - (self.file, self.path) - } - - /// Creates a `NamedTempFile` from its constituent parts. - /// - /// This can be used with [`NamedTempFile::into_parts`] to reconstruct the - /// `NamedTempFile`. - pub fn from_parts(file: F, path: TempPath) -> Self { - Self { file, path } - } -} - -impl NamedTempFile<File> { - /// Securely reopen the temporary file. - /// - /// This function is useful when you need multiple independent handles to - /// the same file. It's perfectly fine to drop the original `NamedTempFile` - /// while holding on to `File`s returned by this function; the `File`s will - /// remain usable. However, they may not be nameable. - /// - /// # Errors - /// - /// If the file cannot be reopened, `Err` is returned. - /// - /// # Security - /// - /// Unlike `File::open(my_temp_file.path())`, `NamedTempFile::reopen()` - /// guarantees that the re-opened file is the _same_ file, even in the - /// presence of pathological temporary file cleaners. - /// - /// # Examples - /// - /// ```no_run - /// # use std::io; - /// use tempfile::NamedTempFile; - /// - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// let file = NamedTempFile::new()?; - /// - /// let another_handle = file.reopen()?; - /// # Ok(()) - /// # } - /// ``` - pub fn reopen(&self) -> io::Result<File> { - imp::reopen(self.as_file(), NamedTempFile::path(self)) - .with_err_path(|| NamedTempFile::path(self)) - } -} - -impl<F: Read> Read for NamedTempFile<F> { - fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - self.as_file_mut().read(buf).with_err_path(|| self.path()) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> { - self.as_file_mut() - .read_vectored(bufs) - .with_err_path(|| self.path()) - } - - fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { - self.as_file_mut() - .read_to_end(buf) - .with_err_path(|| self.path()) - } - - fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { - self.as_file_mut() - .read_to_string(buf) - .with_err_path(|| self.path()) - } - - fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { - self.as_file_mut() - .read_exact(buf) - .with_err_path(|| self.path()) - } -} - -impl Read for &NamedTempFile<File> { - fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - self.as_file().read(buf).with_err_path(|| self.path()) - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> { - self.as_file() - .read_vectored(bufs) - .with_err_path(|| self.path()) - } - - fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { - self.as_file() - .read_to_end(buf) - .with_err_path(|| self.path()) - } - - fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { - self.as_file() - .read_to_string(buf) - .with_err_path(|| self.path()) - } - - fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { - self.as_file().read_exact(buf).with_err_path(|| self.path()) - } -} - -impl<F: Write> Write for NamedTempFile<F> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - self.as_file_mut().write(buf).with_err_path(|| self.path()) - } - #[inline] - fn flush(&mut self) -> io::Result<()> { - self.as_file_mut().flush().with_err_path(|| self.path()) - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> { - self.as_file_mut() - .write_vectored(bufs) - .with_err_path(|| self.path()) - } - - fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { - self.as_file_mut() - .write_all(buf) - .with_err_path(|| self.path()) - } - - fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> { - self.as_file_mut() - .write_fmt(fmt) - .with_err_path(|| self.path()) - } -} - -impl Write for &NamedTempFile<File> { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - self.as_file().write(buf).with_err_path(|| self.path()) - } - #[inline] - fn flush(&mut self) -> io::Result<()> { - self.as_file().flush().with_err_path(|| self.path()) - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> { - self.as_file() - .write_vectored(bufs) - .with_err_path(|| self.path()) - } - - fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { - self.as_file().write_all(buf).with_err_path(|| self.path()) - } - - fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> { - self.as_file().write_fmt(fmt).with_err_path(|| self.path()) - } -} - -impl<F: Seek> Seek for NamedTempFile<F> { - fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { - self.as_file_mut().seek(pos).with_err_path(|| self.path()) - } -} - -impl Seek for &NamedTempFile<File> { - fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { - self.as_file().seek(pos).with_err_path(|| self.path()) - } -} - -#[cfg(any(unix, target_os = "wasi"))] -impl<F: AsFd> AsFd for NamedTempFile<F> { - fn as_fd(&self) -> BorrowedFd<'_> { - self.as_file().as_fd() - } -} - -#[cfg(any(unix, target_os = "wasi"))] -impl<F: AsRawFd> AsRawFd for NamedTempFile<F> { - #[inline] - fn as_raw_fd(&self) -> RawFd { - self.as_file().as_raw_fd() - } -} - -#[cfg(windows)] -impl<F: AsHandle> AsHandle for NamedTempFile<F> { - #[inline] - fn as_handle(&self) -> BorrowedHandle<'_> { - self.as_file().as_handle() - } -} - -#[cfg(windows)] -impl<F: AsRawHandle> AsRawHandle for NamedTempFile<F> { - #[inline] - fn as_raw_handle(&self) -> RawHandle { - self.as_file().as_raw_handle() - } -} - -pub(crate) fn create_named( - mut path: PathBuf, - open_options: &mut OpenOptions, -) -> io::Result<NamedTempFile> { - // Make the path absolute. Otherwise, changing directories could cause us to - // delete the wrong file. - if !path.is_absolute() { - path = env::current_dir()?.join(path) - } - imp::create_named(&path, open_options) - .with_err_path(|| path.clone()) - .map(|file| NamedTempFile { - path: TempPath { - path: path.into_boxed_path(), - }, - file, - }) -} diff --git a/vendor/tempfile/src/lib.rs b/vendor/tempfile/src/lib.rs deleted file mode 100644 index 4b6371d..0000000 --- a/vendor/tempfile/src/lib.rs +++ /dev/null @@ -1,701 +0,0 @@ -//! Temporary files and directories. -//! -//! - Use the [`tempfile()`] function for temporary files -//! - Use the [`tempdir()`] function for temporary directories. -//! -//! # Design -//! -//! This crate provides several approaches to creating temporary files and directories. -//! [`tempfile()`] relies on the OS to remove the temporary file once the last handle is closed. -//! [`TempDir`] and [`NamedTempFile`] both rely on Rust destructors for cleanup. -//! -//! When choosing between the temporary file variants, prefer `tempfile` -//! unless you either need to know the file's path or to be able to persist it. -//! -//! ## Resource Leaking -//! -//! `tempfile` will (almost) never fail to cleanup temporary resources. However `TempDir` and `NamedTempFile` will -//! fail if their destructors don't run. This is because `tempfile` relies on the OS to cleanup the -//! underlying file, while `TempDir` and `NamedTempFile` rely on rust destructors to do so. -//! Destructors may fail to run if the process exits through an unhandled signal interrupt (like `SIGINT`), -//! or if the instance is declared statically (like with [`lazy_static`]), among other possible -//! reasons. -//! -//! ## Security -//! -//! In the presence of pathological temporary file cleaner, relying on file paths is unsafe because -//! a temporary file cleaner could delete the temporary file which an attacker could then replace. -//! -//! `tempfile` doesn't rely on file paths so this isn't an issue. However, `NamedTempFile` does -//! rely on file paths for _some_ operations. See the security documentation on -//! the `NamedTempFile` type for more information. -//! -//! ## Early drop pitfall -//! -//! Because `TempDir` and `NamedTempFile` rely on their destructors for cleanup, this can lead -//! to an unexpected early removal of the directory/file, usually when working with APIs which are -//! generic over `AsRef<Path>`. Consider the following example: -//! -//! ```no_run -//! # use tempfile::tempdir; -//! # use std::io; -//! # use std::process::Command; -//! # fn main() { -//! # if let Err(_) = run() { -//! # ::std::process::exit(1); -//! # } -//! # } -//! # fn run() -> Result<(), io::Error> { -//! // Create a directory inside of `std::env::temp_dir()`. -//! let temp_dir = tempdir()?; -//! -//! // Spawn the `touch` command inside the temporary directory and collect the exit status -//! // Note that `temp_dir` is **not** moved into `current_dir`, but passed as a reference -//! let exit_status = Command::new("touch").arg("tmp").current_dir(&temp_dir).status()?; -//! assert!(exit_status.success()); -//! -//! # Ok(()) -//! # } -//! ``` -//! -//! This works because a reference to `temp_dir` is passed to `current_dir`, resulting in the -//! destructor of `temp_dir` being run after the `Command` has finished execution. Moving the -//! `TempDir` into the `current_dir` call would result in the `TempDir` being converted into -//! an internal representation, with the original value being dropped and the directory thus -//! being deleted, before the command can be executed. -//! -//! The `touch` command would fail with an `No such file or directory` error. -//! -//! ## Examples -//! -//! Create a temporary file and write some data into it: -//! -//! ``` -//! use tempfile::tempfile; -//! use std::io::{self, Write}; -//! -//! # fn main() { -//! # if let Err(_) = run() { -//! # ::std::process::exit(1); -//! # } -//! # } -//! # fn run() -> Result<(), io::Error> { -//! // Create a file inside of `std::env::temp_dir()`. -//! let mut file = tempfile()?; -//! -//! writeln!(file, "Brian was here. Briefly.")?; -//! # Ok(()) -//! # } -//! ``` -//! -//! Create a named temporary file and open an independent file handle: -//! -//! ``` -//! use tempfile::NamedTempFile; -//! use std::io::{self, Write, Read}; -//! -//! # fn main() { -//! # if let Err(_) = run() { -//! # ::std::process::exit(1); -//! # } -//! # } -//! # fn run() -> Result<(), io::Error> { -//! let text = "Brian was here. Briefly."; -//! -//! // Create a file inside of `std::env::temp_dir()`. -//! let mut file1 = NamedTempFile::new()?; -//! -//! // Re-open it. -//! let mut file2 = file1.reopen()?; -//! -//! // Write some test data to the first handle. -//! file1.write_all(text.as_bytes())?; -//! -//! // Read the test data using the second handle. -//! let mut buf = String::new(); -//! file2.read_to_string(&mut buf)?; -//! assert_eq!(buf, text); -//! # Ok(()) -//! # } -//! ``` -//! -//! Create a temporary directory and add a file to it: -//! -//! ``` -//! use tempfile::tempdir; -//! use std::fs::File; -//! use std::io::{self, Write}; -//! -//! # fn main() { -//! # if let Err(_) = run() { -//! # ::std::process::exit(1); -//! # } -//! # } -//! # fn run() -> Result<(), io::Error> { -//! // Create a directory inside of `std::env::temp_dir()`. -//! let dir = tempdir()?; -//! -//! let file_path = dir.path().join("my-temporary-note.txt"); -//! let mut file = File::create(file_path)?; -//! writeln!(file, "Brian was here. Briefly.")?; -//! -//! // By closing the `TempDir` explicitly, we can check that it has -//! // been deleted successfully. If we don't close it explicitly, -//! // the directory will still be deleted when `dir` goes out -//! // of scope, but we won't know whether deleting the directory -//! // succeeded. -//! drop(file); -//! dir.close()?; -//! # Ok(()) -//! # } -//! ``` -//! -//! [`tempfile()`]: fn.tempfile.html -//! [`tempdir()`]: fn.tempdir.html -//! [`TempDir`]: struct.TempDir.html -//! [`NamedTempFile`]: struct.NamedTempFile.html -//! [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html -//! [`lazy_static`]: https://github.com/rust-lang-nursery/lazy-static.rs/issues/62 - -#![doc( - html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", - html_favicon_url = "https://www.rust-lang.org/favicon.ico", - html_root_url = "https://docs.rs/tempfile/3.1.0" -)] -#![cfg_attr(test, deny(warnings))] -#![deny(rust_2018_idioms)] -#![allow(clippy::redundant_field_names)] -#![cfg_attr(all(feature = "nightly", target_os = "wasi"), feature(wasi_ext))] - -#[cfg(doctest)] -doc_comment::doctest!("../README.md"); - -const NUM_RETRIES: u32 = 1 << 31; -const NUM_RAND_CHARS: usize = 6; - -use std::ffi::OsStr; -use std::fs::OpenOptions; -use std::path::Path; -use std::{env, io}; - -mod dir; -mod error; -mod file; -mod spooled; -mod util; - -pub use crate::dir::{tempdir, tempdir_in, TempDir}; -pub use crate::file::{ - tempfile, tempfile_in, NamedTempFile, PathPersistError, PersistError, TempPath, -}; -pub use crate::spooled::{spooled_tempfile, SpooledTempFile}; - -/// Create a new temporary file or directory with custom parameters. -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Builder<'a, 'b> { - random_len: usize, - prefix: &'a OsStr, - suffix: &'b OsStr, - append: bool, -} - -impl<'a, 'b> Default for Builder<'a, 'b> { - fn default() -> Self { - Builder { - random_len: crate::NUM_RAND_CHARS, - prefix: OsStr::new(".tmp"), - suffix: OsStr::new(""), - append: false, - } - } -} - -impl<'a, 'b> Builder<'a, 'b> { - /// Create a new `Builder`. - /// - /// # Examples - /// - /// Create a named temporary file and write some data into it: - /// - /// ``` - /// # use std::io; - /// # use std::ffi::OsStr; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// use tempfile::Builder; - /// - /// let named_tempfile = Builder::new() - /// .prefix("my-temporary-note") - /// .suffix(".txt") - /// .rand_bytes(5) - /// .tempfile()?; - /// - /// let name = named_tempfile - /// .path() - /// .file_name().and_then(OsStr::to_str); - /// - /// if let Some(name) = name { - /// assert!(name.starts_with("my-temporary-note")); - /// assert!(name.ends_with(".txt")); - /// assert_eq!(name.len(), "my-temporary-note.txt".len() + 5); - /// } - /// # Ok(()) - /// # } - /// ``` - /// - /// Create a temporary directory and add a file to it: - /// - /// ``` - /// # use std::io::{self, Write}; - /// # use std::fs::File; - /// # use std::ffi::OsStr; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// use tempfile::Builder; - /// - /// let dir = Builder::new() - /// .prefix("my-temporary-dir") - /// .rand_bytes(5) - /// .tempdir()?; - /// - /// let file_path = dir.path().join("my-temporary-note.txt"); - /// let mut file = File::create(file_path)?; - /// writeln!(file, "Brian was here. Briefly.")?; - /// - /// // By closing the `TempDir` explicitly, we can check that it has - /// // been deleted successfully. If we don't close it explicitly, - /// // the directory will still be deleted when `dir` goes out - /// // of scope, but we won't know whether deleting the directory - /// // succeeded. - /// drop(file); - /// dir.close()?; - /// # Ok(()) - /// # } - /// ``` - /// - /// Create a temporary directory with a chosen prefix under a chosen folder: - /// - /// ```ignore - /// let dir = Builder::new() - /// .prefix("my-temporary-dir") - /// .tempdir_in("folder-with-tempdirs")?; - /// ``` - #[must_use] - pub fn new() -> Self { - Self::default() - } - - /// Set a custom filename prefix. - /// - /// Path separators are legal but not advisable. - /// Default: `.tmp`. - /// - /// # Examples - /// - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// let named_tempfile = Builder::new() - /// .prefix("my-temporary-note") - /// .tempfile()?; - /// # Ok(()) - /// # } - /// ``` - pub fn prefix<S: AsRef<OsStr> + ?Sized>(&mut self, prefix: &'a S) -> &mut Self { - self.prefix = prefix.as_ref(); - self - } - - /// Set a custom filename suffix. - /// - /// Path separators are legal but not advisable. - /// Default: empty. - /// - /// # Examples - /// - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// let named_tempfile = Builder::new() - /// .suffix(".txt") - /// .tempfile()?; - /// # Ok(()) - /// # } - /// ``` - pub fn suffix<S: AsRef<OsStr> + ?Sized>(&mut self, suffix: &'b S) -> &mut Self { - self.suffix = suffix.as_ref(); - self - } - - /// Set the number of random bytes. - /// - /// Default: `6`. - /// - /// # Examples - /// - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// let named_tempfile = Builder::new() - /// .rand_bytes(5) - /// .tempfile()?; - /// # Ok(()) - /// # } - /// ``` - pub fn rand_bytes(&mut self, rand: usize) -> &mut Self { - self.random_len = rand; - self - } - - /// Set the file to be opened in append mode. - /// - /// Default: `false`. - /// - /// # Examples - /// - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// let named_tempfile = Builder::new() - /// .append(true) - /// .tempfile()?; - /// # Ok(()) - /// # } - /// ``` - pub fn append(&mut self, append: bool) -> &mut Self { - self.append = append; - self - } - - /// Create the named temporary file. - /// - /// # Security - /// - /// See [the security][security] docs on `NamedTempFile`. - /// - /// # Resource leaking - /// - /// See [the resource leaking][resource-leaking] docs on `NamedTempFile`. - /// - /// # Errors - /// - /// If the file cannot be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// let tempfile = Builder::new().tempfile()?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [security]: struct.NamedTempFile.html#security - /// [resource-leaking]: struct.NamedTempFile.html#resource-leaking - pub fn tempfile(&self) -> io::Result<NamedTempFile> { - self.tempfile_in(env::temp_dir()) - } - - /// Create the named temporary file in the specified directory. - /// - /// # Security - /// - /// See [the security][security] docs on `NamedTempFile`. - /// - /// # Resource leaking - /// - /// See [the resource leaking][resource-leaking] docs on `NamedTempFile`. - /// - /// # Errors - /// - /// If the file cannot be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// let tempfile = Builder::new().tempfile_in("./")?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [security]: struct.NamedTempFile.html#security - /// [resource-leaking]: struct.NamedTempFile.html#resource-leaking - pub fn tempfile_in<P: AsRef<Path>>(&self, dir: P) -> io::Result<NamedTempFile> { - util::create_helper( - dir.as_ref(), - self.prefix, - self.suffix, - self.random_len, - |path| file::create_named(path, OpenOptions::new().append(self.append)), - ) - } - - /// Attempts to make a temporary directory inside of `env::temp_dir()` whose - /// name will have the prefix, `prefix`. The directory and - /// everything inside it will be automatically deleted once the - /// returned `TempDir` is destroyed. - /// - /// # Resource leaking - /// - /// See [the resource leaking][resource-leaking] docs on `TempDir`. - /// - /// # Errors - /// - /// If the directory can not be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// use std::fs::File; - /// use std::io::Write; - /// use tempfile::Builder; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// let tmp_dir = Builder::new().tempdir()?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [resource-leaking]: struct.TempDir.html#resource-leaking - pub fn tempdir(&self) -> io::Result<TempDir> { - self.tempdir_in(env::temp_dir()) - } - - /// Attempts to make a temporary directory inside of `dir`. - /// The directory and everything inside it will be automatically - /// deleted once the returned `TempDir` is destroyed. - /// - /// # Resource leaking - /// - /// See [the resource leaking][resource-leaking] docs on `TempDir`. - /// - /// # Errors - /// - /// If the directory can not be created, `Err` is returned. - /// - /// # Examples - /// - /// ``` - /// use std::fs::{self, File}; - /// use std::io::Write; - /// use tempfile::Builder; - /// - /// # use std::io; - /// # fn run() -> Result<(), io::Error> { - /// let tmp_dir = Builder::new().tempdir_in("./")?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [resource-leaking]: struct.TempDir.html#resource-leaking - pub fn tempdir_in<P: AsRef<Path>>(&self, dir: P) -> io::Result<TempDir> { - let storage; - let mut dir = dir.as_ref(); - if !dir.is_absolute() { - let cur_dir = env::current_dir()?; - storage = cur_dir.join(dir); - dir = &storage; - } - - util::create_helper(dir, self.prefix, self.suffix, self.random_len, dir::create) - } - - /// Attempts to create a temporary file (or file-like object) using the - /// provided closure. The closure is passed a temporary file path and - /// returns an [`std::io::Result`]. The path provided to the closure will be - /// inside of [`std::env::temp_dir()`]. Use [`Builder::make_in`] to provide - /// a custom temporary directory. If the closure returns one of the - /// following errors, then another randomized file path is tried: - /// - [`std::io::ErrorKind::AlreadyExists`] - /// - [`std::io::ErrorKind::AddrInUse`] - /// - /// This can be helpful for taking full control over the file creation, but - /// leaving the temporary file path construction up to the library. This - /// also enables creating a temporary UNIX domain socket, since it is not - /// possible to bind to a socket that already exists. - /// - /// Note that [`Builder::append`] is ignored when using [`Builder::make`]. - /// - /// # Security - /// - /// This has the same [security implications][security] as - /// [`NamedTempFile`], but with additional caveats. Specifically, it is up - /// to the closure to ensure that the file does not exist and that such a - /// check is *atomic*. Otherwise, a [time-of-check to time-of-use - /// bug][TOCTOU] could be introduced. - /// - /// For example, the following is **not** secure: - /// - /// ``` - /// # use std::io; - /// # use std::fs::File; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// // This is NOT secure! - /// let tempfile = Builder::new().make(|path| { - /// if path.is_file() { - /// return Err(io::ErrorKind::AlreadyExists.into()); - /// } - /// - /// // Between the check above and the usage below, an attacker could - /// // have replaced `path` with another file, which would get truncated - /// // by `File::create`. - /// - /// File::create(path) - /// })?; - /// # Ok(()) - /// # } - /// ``` - /// Note that simply using [`std::fs::File::create`] alone is not correct - /// because it does not fail if the file already exists: - /// ``` - /// # use std::io; - /// # use std::fs::File; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// // This could overwrite an existing file! - /// let tempfile = Builder::new().make(|path| File::create(path))?; - /// # Ok(()) - /// # } - /// ``` - /// For creating regular temporary files, use [`Builder::tempfile`] instead - /// to avoid these problems. This function is meant to enable more exotic - /// use-cases. - /// - /// # Resource leaking - /// - /// See [the resource leaking][resource-leaking] docs on `NamedTempFile`. - /// - /// # Errors - /// - /// If the closure returns any error besides - /// [`std::io::ErrorKind::AlreadyExists`] or - /// [`std::io::ErrorKind::AddrInUse`], then `Err` is returned. - /// - /// # Examples - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// # #[cfg(unix)] - /// use std::os::unix::net::UnixListener; - /// # #[cfg(unix)] - /// let tempsock = Builder::new().make(|path| UnixListener::bind(path))?; - /// # Ok(()) - /// # } - /// ``` - /// - /// [TOCTOU]: https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use - /// [security]: struct.NamedTempFile.html#security - /// [resource-leaking]: struct.NamedTempFile.html#resource-leaking - pub fn make<F, R>(&self, f: F) -> io::Result<NamedTempFile<R>> - where - F: FnMut(&Path) -> io::Result<R>, - { - self.make_in(env::temp_dir(), f) - } - - /// This is the same as [`Builder::make`], except `dir` is used as the base - /// directory for the temporary file path. - /// - /// See [`Builder::make`] for more details and security implications. - /// - /// # Examples - /// ``` - /// # use std::io; - /// # fn main() { - /// # if let Err(_) = run() { - /// # ::std::process::exit(1); - /// # } - /// # } - /// # fn run() -> Result<(), io::Error> { - /// # use tempfile::Builder; - /// # #[cfg(unix)] - /// use std::os::unix::net::UnixListener; - /// # #[cfg(unix)] - /// let tempsock = Builder::new().make_in("./", |path| UnixListener::bind(path))?; - /// # Ok(()) - /// # } - /// ``` - pub fn make_in<F, R, P>(&self, dir: P, mut f: F) -> io::Result<NamedTempFile<R>> - where - F: FnMut(&Path) -> io::Result<R>, - P: AsRef<Path>, - { - util::create_helper( - dir.as_ref(), - self.prefix, - self.suffix, - self.random_len, - move |path| { - Ok(NamedTempFile::from_parts( - f(&path)?, - TempPath::from_path(path), - )) - }, - ) - } -} diff --git a/vendor/tempfile/src/spooled.rs b/vendor/tempfile/src/spooled.rs deleted file mode 100644 index 2c8eaa4..0000000 --- a/vendor/tempfile/src/spooled.rs +++ /dev/null @@ -1,203 +0,0 @@ -use crate::file::tempfile; -use std::fs::File; -use std::io::{self, Cursor, Read, Seek, SeekFrom, Write}; - -/// A wrapper for the two states of a `SpooledTempFile`. -#[derive(Debug)] -pub enum SpooledData { - InMemory(Cursor<Vec<u8>>), - OnDisk(File), -} - -/// An object that behaves like a regular temporary file, but keeps data in -/// memory until it reaches a configured size, at which point the data is -/// written to a temporary file on disk, and further operations use the file -/// on disk. -#[derive(Debug)] -pub struct SpooledTempFile { - max_size: usize, - inner: SpooledData, -} - -/// Create a new spooled temporary file. -/// -/// # Security -/// -/// This variant is secure/reliable in the presence of a pathological temporary -/// file cleaner. -/// -/// # Resource Leaking -/// -/// The temporary file will be automatically removed by the OS when the last -/// handle to it is closed. This doesn't rely on Rust destructors being run, so -/// will (almost) never fail to clean up the temporary file. -/// -/// # Examples -/// -/// ``` -/// use tempfile::spooled_tempfile; -/// use std::io::{self, Write}; -/// -/// # fn main() { -/// # if let Err(_) = run() { -/// # ::std::process::exit(1); -/// # } -/// # } -/// # fn run() -> Result<(), io::Error> { -/// let mut file = spooled_tempfile(15); -/// -/// writeln!(file, "short line")?; -/// assert!(!file.is_rolled()); -/// -/// // as a result of this write call, the size of the data will exceed -/// // `max_size` (15), so it will be written to a temporary file on disk, -/// // and the in-memory buffer will be dropped -/// writeln!(file, "marvin gardens")?; -/// assert!(file.is_rolled()); -/// -/// # Ok(()) -/// # } -/// ``` -#[inline] -pub fn spooled_tempfile(max_size: usize) -> SpooledTempFile { - SpooledTempFile::new(max_size) -} - -impl SpooledTempFile { - #[must_use] - pub fn new(max_size: usize) -> SpooledTempFile { - SpooledTempFile { - max_size, - inner: SpooledData::InMemory(Cursor::new(Vec::new())), - } - } - - /// Returns true if the file has been rolled over to disk. - #[must_use] - pub fn is_rolled(&self) -> bool { - match self.inner { - SpooledData::InMemory(_) => false, - SpooledData::OnDisk(_) => true, - } - } - - /// Rolls over to a file on disk, regardless of current size. Does nothing - /// if already rolled over. - pub fn roll(&mut self) -> io::Result<()> { - if !self.is_rolled() { - let mut file = tempfile()?; - if let SpooledData::InMemory(cursor) = &mut self.inner { - file.write_all(cursor.get_ref())?; - file.seek(SeekFrom::Start(cursor.position()))?; - } - self.inner = SpooledData::OnDisk(file); - } - Ok(()) - } - - pub fn set_len(&mut self, size: u64) -> Result<(), io::Error> { - if size as usize > self.max_size { - self.roll()?; // does nothing if already rolled over - } - match &mut self.inner { - SpooledData::InMemory(cursor) => { - cursor.get_mut().resize(size as usize, 0); - Ok(()) - } - SpooledData::OnDisk(file) => file.set_len(size), - } - } - - /// Consumes and returns the inner `SpooledData` type. - #[must_use] - pub fn into_inner(self) -> SpooledData { - self.inner - } -} - -impl Read for SpooledTempFile { - fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.read(buf), - SpooledData::OnDisk(file) => file.read(buf), - } - } - - fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.read_vectored(bufs), - SpooledData::OnDisk(file) => file.read_vectored(bufs), - } - } - - fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.read_to_end(buf), - SpooledData::OnDisk(file) => file.read_to_end(buf), - } - } - - fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.read_to_string(buf), - SpooledData::OnDisk(file) => file.read_to_string(buf), - } - } - - fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.read_exact(buf), - SpooledData::OnDisk(file) => file.read_exact(buf), - } - } -} - -impl Write for SpooledTempFile { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { - // roll over to file if necessary - if matches! { - &self.inner, SpooledData::InMemory(cursor) - if cursor.position() as usize + buf.len() > self.max_size - } { - self.roll()?; - } - - // write the bytes - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.write(buf), - SpooledData::OnDisk(file) => file.write(buf), - } - } - - fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> { - if matches! { - &self.inner, SpooledData::InMemory(cursor) - // Borrowed from the rust standard library. - if cursor.position() as usize + bufs.iter() - .fold(0usize, |a, b| a.saturating_add(b.len())) > self.max_size - } { - self.roll()?; - } - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.write_vectored(bufs), - SpooledData::OnDisk(file) => file.write_vectored(bufs), - } - } - - #[inline] - fn flush(&mut self) -> io::Result<()> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.flush(), - SpooledData::OnDisk(file) => file.flush(), - } - } -} - -impl Seek for SpooledTempFile { - fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { - match &mut self.inner { - SpooledData::InMemory(cursor) => cursor.seek(pos), - SpooledData::OnDisk(file) => file.seek(pos), - } - } -} diff --git a/vendor/tempfile/src/util.rs b/vendor/tempfile/src/util.rs deleted file mode 100644 index d426ba3..0000000 --- a/vendor/tempfile/src/util.rs +++ /dev/null @@ -1,47 +0,0 @@ -use std::ffi::{OsStr, OsString}; -use std::path::{Path, PathBuf}; -use std::{io, iter::repeat_with}; - -use crate::error::IoResultExt; - -fn tmpname(prefix: &OsStr, suffix: &OsStr, rand_len: usize) -> OsString { - let mut buf = OsString::with_capacity(prefix.len() + suffix.len() + rand_len); - buf.push(prefix); - let mut char_buf = [0u8; 4]; - for c in repeat_with(fastrand::alphanumeric).take(rand_len) { - buf.push(c.encode_utf8(&mut char_buf)); - } - buf.push(suffix); - buf -} - -pub fn create_helper<R>( - base: &Path, - prefix: &OsStr, - suffix: &OsStr, - random_len: usize, - mut f: impl FnMut(PathBuf) -> io::Result<R>, -) -> io::Result<R> { - let num_retries = if random_len != 0 { - crate::NUM_RETRIES - } else { - 1 - }; - - for _ in 0..num_retries { - let path = base.join(tmpname(prefix, suffix, random_len)); - return match f(path) { - Err(ref e) if e.kind() == io::ErrorKind::AlreadyExists && num_retries > 1 => continue, - // AddrInUse can happen if we're creating a UNIX domain socket and - // the path already exists. - Err(ref e) if e.kind() == io::ErrorKind::AddrInUse && num_retries > 1 => continue, - res => res, - }; - } - - Err(io::Error::new( - io::ErrorKind::AlreadyExists, - "too many temporary files exist", - )) - .with_err_path(|| base) -} diff --git a/vendor/tempfile/tests/namedtempfile.rs b/vendor/tempfile/tests/namedtempfile.rs deleted file mode 100644 index 4b940b6..0000000 --- a/vendor/tempfile/tests/namedtempfile.rs +++ /dev/null @@ -1,473 +0,0 @@ -#![deny(rust_2018_idioms)] - -use std::env; -use std::ffi::{OsStr, OsString}; -use std::fs::File; -use std::io::{Read, Seek, SeekFrom, Write}; -use std::path::{Path, PathBuf}; -use tempfile::{tempdir, Builder, NamedTempFile, TempPath}; - -fn exists<P: AsRef<Path>>(path: P) -> bool { - std::fs::metadata(path.as_ref()).is_ok() -} - -#[test] -fn test_prefix() { - let tmpfile = NamedTempFile::with_prefix("prefix").unwrap(); - let name = tmpfile.path().file_name().unwrap().to_str().unwrap(); - assert!(name.starts_with("prefix")); -} - -#[test] -fn test_basic() { - let mut tmpfile = NamedTempFile::new().unwrap(); - write!(tmpfile, "abcde").unwrap(); - tmpfile.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - tmpfile.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); -} - -#[test] -fn test_deleted() { - let tmpfile = NamedTempFile::new().unwrap(); - let path = tmpfile.path().to_path_buf(); - assert!(exists(&path)); - drop(tmpfile); - assert!(!exists(&path)); -} - -#[test] -fn test_persist() { - let mut tmpfile = NamedTempFile::new().unwrap(); - let old_path = tmpfile.path().to_path_buf(); - let persist_path = env::temp_dir().join("persisted_temporary_file"); - write!(tmpfile, "abcde").unwrap(); - { - assert!(exists(&old_path)); - let mut f = tmpfile.persist(&persist_path).unwrap(); - assert!(!exists(&old_path)); - - // Check original file - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - } - - { - // Try opening it at the new path. - let mut f = File::open(&persist_path).unwrap(); - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - } - std::fs::remove_file(&persist_path).unwrap(); -} - -#[test] -fn test_persist_noclobber() { - let mut tmpfile = NamedTempFile::new().unwrap(); - let old_path = tmpfile.path().to_path_buf(); - let persist_target = NamedTempFile::new().unwrap(); - let persist_path = persist_target.path().to_path_buf(); - write!(tmpfile, "abcde").unwrap(); - assert!(exists(&old_path)); - { - tmpfile = tmpfile.persist_noclobber(&persist_path).unwrap_err().into(); - assert!(exists(&old_path)); - std::fs::remove_file(&persist_path).unwrap(); - drop(persist_target); - } - tmpfile.persist_noclobber(&persist_path).unwrap(); - // Try opening it at the new path. - let mut f = File::open(&persist_path).unwrap(); - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - std::fs::remove_file(&persist_path).unwrap(); -} - -#[test] -fn test_customnamed() { - let tmpfile = Builder::new() - .prefix("tmp") - .suffix(&".rs") - .rand_bytes(12) - .tempfile() - .unwrap(); - let name = tmpfile.path().file_name().unwrap().to_str().unwrap(); - assert!(name.starts_with("tmp")); - assert!(name.ends_with(".rs")); - assert_eq!(name.len(), 18); -} - -#[test] -fn test_append() { - let mut tmpfile = Builder::new().append(true).tempfile().unwrap(); - tmpfile.write_all(b"a").unwrap(); - tmpfile.seek(SeekFrom::Start(0)).unwrap(); - tmpfile.write_all(b"b").unwrap(); - - tmpfile.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = vec![0u8; 1]; - tmpfile.read_exact(&mut buf).unwrap(); - assert_eq!(buf, b"a"); -} - -#[test] -fn test_reopen() { - let source = NamedTempFile::new().unwrap(); - let mut first = source.reopen().unwrap(); - let mut second = source.reopen().unwrap(); - drop(source); - - write!(first, "abcde").expect("write failed"); - let mut buf = String::new(); - second.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); -} - -#[test] -fn test_into_file() { - let mut file = NamedTempFile::new().unwrap(); - let path = file.path().to_owned(); - write!(file, "abcde").expect("write failed"); - - assert!(path.exists()); - let mut file = file.into_file(); - assert!(!path.exists()); - - file.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - file.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); -} - -#[test] -fn test_immut() { - let tmpfile = NamedTempFile::new().unwrap(); - (&tmpfile).write_all(b"abcde").unwrap(); - (&tmpfile).seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - (&tmpfile).read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); -} - -#[test] -fn test_temppath() { - let mut tmpfile = NamedTempFile::new().unwrap(); - write!(tmpfile, "abcde").unwrap(); - - let path = tmpfile.into_temp_path(); - assert!(path.is_file()); -} - -#[test] -fn test_temppath_persist() { - let mut tmpfile = NamedTempFile::new().unwrap(); - write!(tmpfile, "abcde").unwrap(); - - let tmppath = tmpfile.into_temp_path(); - - let old_path = tmppath.to_path_buf(); - let persist_path = env::temp_dir().join("persisted_temppath_file"); - - { - assert!(exists(&old_path)); - tmppath.persist(&persist_path).unwrap(); - assert!(!exists(&old_path)); - } - - { - // Try opening it at the new path. - let mut f = File::open(&persist_path).unwrap(); - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - } - - std::fs::remove_file(&persist_path).unwrap(); -} - -#[test] -fn test_temppath_persist_noclobber() { - let mut tmpfile = NamedTempFile::new().unwrap(); - write!(tmpfile, "abcde").unwrap(); - - let mut tmppath = tmpfile.into_temp_path(); - - let old_path = tmppath.to_path_buf(); - let persist_target = NamedTempFile::new().unwrap(); - let persist_path = persist_target.path().to_path_buf(); - - assert!(exists(&old_path)); - - { - tmppath = tmppath.persist_noclobber(&persist_path).unwrap_err().into(); - assert!(exists(&old_path)); - std::fs::remove_file(&persist_path).unwrap(); - drop(persist_target); - } - - tmppath.persist_noclobber(&persist_path).unwrap(); - - // Try opening it at the new path. - let mut f = File::open(&persist_path).unwrap(); - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - std::fs::remove_file(&persist_path).unwrap(); -} - -#[test] -fn temp_path_from_existing() { - let tmp_dir = tempdir().unwrap(); - let tmp_file_path_1 = tmp_dir.path().join("testfile1"); - let tmp_file_path_2 = tmp_dir.path().join("testfile2"); - - File::create(&tmp_file_path_1).unwrap(); - assert!(tmp_file_path_1.exists(), "Test file 1 hasn't been created"); - - File::create(&tmp_file_path_2).unwrap(); - assert!(tmp_file_path_2.exists(), "Test file 2 hasn't been created"); - - let tmp_path = TempPath::from_path(&tmp_file_path_1); - assert!( - tmp_file_path_1.exists(), - "Test file has been deleted before dropping TempPath" - ); - - drop(tmp_path); - assert!( - !tmp_file_path_1.exists(), - "Test file exists after dropping TempPath" - ); - assert!( - tmp_file_path_2.exists(), - "Test file 2 has been deleted before dropping TempDir" - ); -} - -#[test] -#[allow(unreachable_code)] -fn temp_path_from_argument_types() { - // This just has to compile - return; - - TempPath::from_path(""); - TempPath::from_path(String::new()); - TempPath::from_path(OsStr::new("")); - TempPath::from_path(OsString::new()); - TempPath::from_path(Path::new("")); - TempPath::from_path(PathBuf::new()); - TempPath::from_path(PathBuf::new().into_boxed_path()); -} - -#[test] -fn test_write_after_close() { - let path = NamedTempFile::new().unwrap().into_temp_path(); - File::create(path).unwrap().write_all(b"test").unwrap(); -} - -#[test] -fn test_change_dir() { - env::set_current_dir(env::temp_dir()).unwrap(); - let tmpfile = NamedTempFile::new_in(".").unwrap(); - let path = env::current_dir().unwrap().join(tmpfile.path()); - env::set_current_dir("/").unwrap(); - drop(tmpfile); - assert!(!exists(path)) -} - -#[test] -fn test_into_parts() { - let mut file = NamedTempFile::new().unwrap(); - write!(file, "abcd").expect("write failed"); - - let (mut file, temp_path) = file.into_parts(); - - let path = temp_path.to_path_buf(); - - assert!(path.exists()); - drop(temp_path); - assert!(!path.exists()); - - write!(file, "efgh").expect("write failed"); - - file.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - file.read_to_string(&mut buf).unwrap(); - assert_eq!("abcdefgh", buf); -} - -#[test] -fn test_from_parts() { - let mut file = NamedTempFile::new().unwrap(); - write!(file, "abcd").expect("write failed"); - - let (file, temp_path) = file.into_parts(); - - let file = NamedTempFile::from_parts(file, temp_path); - - assert!(file.path().exists()); -} - -#[test] -fn test_keep() { - let mut tmpfile = NamedTempFile::new().unwrap(); - write!(tmpfile, "abcde").unwrap(); - let (mut f, temp_path) = tmpfile.into_parts(); - let path; - { - assert!(exists(&temp_path)); - path = temp_path.keep().unwrap(); - assert!(exists(&path)); - - // Check original file - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - } - - { - // Try opening it again. - let mut f = File::open(&path).unwrap(); - f.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - f.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - } - std::fs::remove_file(&path).unwrap(); -} - -#[test] -fn test_make() { - let tmpfile = Builder::new().make(|path| File::create(path)).unwrap(); - - assert!(tmpfile.path().is_file()); -} - -#[test] -fn test_make_in() { - let tmp_dir = tempdir().unwrap(); - - let tmpfile = Builder::new() - .make_in(tmp_dir.path(), |path| File::create(path)) - .unwrap(); - - assert!(tmpfile.path().is_file()); - assert_eq!(tmpfile.path().parent(), Some(tmp_dir.path())); -} - -#[test] -fn test_make_fnmut() { - let mut count = 0; - - // Show that an FnMut can be used. - let tmpfile = Builder::new() - .make(|path| { - count += 1; - File::create(path) - }) - .unwrap(); - - assert!(tmpfile.path().is_file()); -} - -#[cfg(unix)] -#[test] -fn test_make_uds() { - use std::os::unix::net::UnixListener; - - let temp_sock = Builder::new() - .prefix("tmp") - .suffix(".sock") - .rand_bytes(12) - .make(|path| UnixListener::bind(path)) - .unwrap(); - - assert!(temp_sock.path().exists()); -} - -#[cfg(unix)] -#[test] -fn test_make_uds_conflict() { - use std::os::unix::net::UnixListener; - use std::sync::atomic::{AtomicUsize, Ordering}; - use std::sync::Arc; - - // Check that retries happen correctly by racing N different threads. - - const NTHREADS: usize = 20; - - // The number of times our callback was called. - let tries = Arc::new(AtomicUsize::new(0)); - - let mut threads = Vec::with_capacity(NTHREADS); - - for _ in 0..NTHREADS { - let tries = tries.clone(); - threads.push(std::thread::spawn(move || { - // Ensure that every thread uses the same seed so we are guaranteed - // to retry. Note that fastrand seeds are thread-local. - fastrand::seed(42); - - Builder::new() - .prefix("tmp") - .suffix(".sock") - .rand_bytes(12) - .make(|path| { - tries.fetch_add(1, Ordering::Relaxed); - UnixListener::bind(path) - }) - })); - } - - // Join all threads, but don't drop the temp file yet. Otherwise, we won't - // get a deterministic number of `tries`. - let sockets: Vec<_> = threads - .into_iter() - .map(|thread| thread.join().unwrap().unwrap()) - .collect(); - - // Number of tries is exactly equal to (n*(n+1))/2. - assert_eq!( - tries.load(Ordering::Relaxed), - (NTHREADS * (NTHREADS + 1)) / 2 - ); - - for socket in sockets { - assert!(socket.path().exists()); - } -} - -// Issue #224. -#[test] -fn test_overly_generic_bounds() { - pub struct Foo<T>(T); - - impl<T> Foo<T> - where - T: Sync + Send + 'static, - for<'a> &'a T: Write + Read, - { - pub fn new(foo: T) -> Self { - Self(foo) - } - } - - // Don't really need to run this. Only care if it compiles. - if let Ok(file) = File::open("i_do_not_exist") { - let mut f; - let _x = { - f = Foo::new(file); - &mut f - }; - } -} diff --git a/vendor/tempfile/tests/spooled.rs b/vendor/tempfile/tests/spooled.rs deleted file mode 100644 index a3bcc03..0000000 --- a/vendor/tempfile/tests/spooled.rs +++ /dev/null @@ -1,307 +0,0 @@ -#![deny(rust_2018_idioms)] - -use std::io::{Read, Seek, SeekFrom, Write}; - -use tempfile::{spooled_tempfile, SpooledTempFile}; - -#[test] -fn test_automatic_rollover() { - let mut t = spooled_tempfile(10); - let mut buf = Vec::new(); - - assert!(!t.is_rolled()); - assert_eq!(t.stream_position().unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 0); - assert_eq!(buf.as_slice(), b""); - buf.clear(); - - assert_eq!(t.write(b"abcde").unwrap(), 5); - - assert!(!t.is_rolled()); - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 5); - assert_eq!(buf.as_slice(), b"abcde"); - - assert_eq!(t.write(b"fghijklmno").unwrap(), 10); - - assert_eq!(t.stream_position().unwrap(), 15); - assert!(t.is_rolled()); -} - -#[test] -fn test_explicit_rollover() { - let mut t = SpooledTempFile::new(100); - assert_eq!(t.write(b"abcdefghijklmnopqrstuvwxyz").unwrap(), 26); - assert_eq!(t.stream_position().unwrap(), 26); - assert!(!t.is_rolled()); - - // roll over explicitly - assert!(t.roll().is_ok()); - assert!(t.is_rolled()); - assert_eq!(t.stream_position().unwrap(), 26); - - let mut buf = Vec::new(); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 0); - assert_eq!(buf.as_slice(), b""); - buf.clear(); - - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 26); - assert_eq!(buf.as_slice(), b"abcdefghijklmnopqrstuvwxyz"); - assert_eq!(t.stream_position().unwrap(), 26); -} - -// called by test_seek_{buffer, file} -// assumes t is empty and offset is 0 to start -fn test_seek(t: &mut SpooledTempFile) { - assert_eq!(t.write(b"abcdefghijklmnopqrstuvwxyz").unwrap(), 26); - - assert_eq!(t.stream_position().unwrap(), 26); // tell() - assert_eq!(t.seek(SeekFrom::Current(-1)).unwrap(), 25); - assert_eq!(t.seek(SeekFrom::Current(1)).unwrap(), 26); - assert_eq!(t.seek(SeekFrom::Current(1)).unwrap(), 27); - assert_eq!(t.seek(SeekFrom::Current(-27)).unwrap(), 0); - assert!(t.seek(SeekFrom::Current(-1)).is_err()); - assert!(t.seek(SeekFrom::Current(-1245)).is_err()); - - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.seek(SeekFrom::Start(1)).unwrap(), 1); - assert_eq!(t.seek(SeekFrom::Start(26)).unwrap(), 26); - assert_eq!(t.seek(SeekFrom::Start(27)).unwrap(), 27); - // // these are build errors - // assert!(t.seek(SeekFrom::Start(-1)).is_err()); - // assert!(t.seek(SeekFrom::Start(-1000)).is_err()); - - assert_eq!(t.seek(SeekFrom::End(0)).unwrap(), 26); - assert_eq!(t.seek(SeekFrom::End(-1)).unwrap(), 25); - assert_eq!(t.seek(SeekFrom::End(-26)).unwrap(), 0); - assert!(t.seek(SeekFrom::End(-27)).is_err()); - assert!(t.seek(SeekFrom::End(-99)).is_err()); - assert_eq!(t.seek(SeekFrom::End(1)).unwrap(), 27); - assert_eq!(t.seek(SeekFrom::End(1)).unwrap(), 27); -} - -#[test] -fn test_seek_buffer() { - let mut t = spooled_tempfile(100); - test_seek(&mut t); -} - -#[test] -fn test_seek_file() { - let mut t = SpooledTempFile::new(10); - test_seek(&mut t); -} - -fn test_seek_read(t: &mut SpooledTempFile) { - assert_eq!(t.write(b"abcdefghijklmnopqrstuvwxyz").unwrap(), 26); - - let mut buf = Vec::new(); - - // we're at the end - assert_eq!(t.read_to_end(&mut buf).unwrap(), 0); - assert_eq!(buf.as_slice(), b""); - buf.clear(); - - // seek to start, read whole thing - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 26); - assert_eq!(buf.as_slice(), b"abcdefghijklmnopqrstuvwxyz"); - buf.clear(); - - // now we're at the end again - assert_eq!(t.stream_position().unwrap(), 26); // tell() - assert_eq!(t.read_to_end(&mut buf).unwrap(), 0); - assert_eq!(buf.as_slice(), b""); - buf.clear(); - - // seek to somewhere in the middle, read a bit - assert_eq!(t.seek(SeekFrom::Start(5)).unwrap(), 5); - let mut buf = [0; 5]; - assert!(t.read_exact(&mut buf).is_ok()); - assert_eq!(buf, *b"fghij"); - - // read again from current spot - assert_eq!(t.stream_position().unwrap(), 10); // tell() - assert!(t.read_exact(&mut buf).is_ok()); - assert_eq!(buf, *b"klmno"); - - let mut buf = [0; 15]; - // partial read - assert_eq!(t.read(&mut buf).unwrap(), 11); - assert_eq!(buf[0..11], *b"pqrstuvwxyz"); - - // try to read off the end: UnexpectedEof - assert!(t.read_exact(&mut buf).is_err()); -} - -#[test] -fn test_seek_read_buffer() { - let mut t = spooled_tempfile(100); - test_seek_read(&mut t); -} - -#[test] -fn test_seek_read_file() { - let mut t = SpooledTempFile::new(10); - test_seek_read(&mut t); -} - -fn test_overwrite_middle(t: &mut SpooledTempFile) { - assert_eq!(t.write(b"abcdefghijklmnopqrstuvwxyz").unwrap(), 26); - - assert_eq!(t.seek(SeekFrom::Start(10)).unwrap(), 10); - assert_eq!(t.write(b"0123456789").unwrap(), 10); - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - - let mut buf = Vec::new(); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 26); - assert_eq!(buf.as_slice(), b"abcdefghij0123456789uvwxyz"); -} - -#[test] -fn test_overwrite_middle_of_buffer() { - let mut t = spooled_tempfile(100); - test_overwrite_middle(&mut t); -} - -#[test] -fn test_overwrite_middle_of_file() { - let mut t = SpooledTempFile::new(10); - test_overwrite_middle(&mut t); -} - -#[test] -fn test_overwrite_and_extend_buffer() { - let mut t = spooled_tempfile(100); - assert_eq!(t.write(b"abcdefghijklmnopqrstuvwxyz").unwrap(), 26); - assert_eq!(t.seek(SeekFrom::End(-5)).unwrap(), 21); - assert_eq!(t.write(b"0123456789").unwrap(), 10); - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - let mut buf = Vec::new(); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 31); - assert_eq!(buf.as_slice(), b"abcdefghijklmnopqrstu0123456789"); - assert!(!t.is_rolled()); -} - -#[test] -fn test_overwrite_and_extend_rollover() { - let mut t = SpooledTempFile::new(20); - assert_eq!(t.write(b"abcdefghijklmno").unwrap(), 15); - assert!(!t.is_rolled()); - assert_eq!(t.seek(SeekFrom::End(-5)).unwrap(), 10); - assert_eq!(t.stream_position().unwrap(), 10); // tell() - assert!(!t.is_rolled()); - assert_eq!(t.write(b"0123456789)!@#$%^&*(").unwrap(), 20); - assert!(t.is_rolled()); - assert_eq!(t.stream_position().unwrap(), 30); // tell() - let mut buf = Vec::new(); - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 30); - assert_eq!(buf.as_slice(), b"abcdefghij0123456789)!@#$%^&*("); -} - -fn test_sparse(t: &mut SpooledTempFile) { - assert_eq!(t.write(b"abcde").unwrap(), 5); - assert_eq!(t.seek(SeekFrom::Current(5)).unwrap(), 10); - assert_eq!(t.write(b"klmno").unwrap(), 5); - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - let mut buf = Vec::new(); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 15); - assert_eq!(buf.as_slice(), b"abcde\0\0\0\0\0klmno"); -} - -#[test] -fn test_sparse_buffer() { - let mut t = spooled_tempfile(100); - test_sparse(&mut t); -} - -#[test] -fn test_sparse_file() { - let mut t = SpooledTempFile::new(1); - test_sparse(&mut t); -} - -#[test] -fn test_sparse_write_rollover() { - let mut t = spooled_tempfile(10); - assert_eq!(t.write(b"abcde").unwrap(), 5); - assert!(!t.is_rolled()); - assert_eq!(t.seek(SeekFrom::Current(5)).unwrap(), 10); - assert!(!t.is_rolled()); - assert_eq!(t.write(b"klmno").unwrap(), 5); - assert!(t.is_rolled()); - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - let mut buf = Vec::new(); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 15); - assert_eq!(buf.as_slice(), b"abcde\0\0\0\0\0klmno"); -} - -fn test_set_len(t: &mut SpooledTempFile) { - let mut buf: Vec<u8> = Vec::new(); - - assert_eq!(t.write(b"abcdefghijklmnopqrstuvwxyz").unwrap(), 26); - - // truncate to 10 bytes - assert!(t.set_len(10).is_ok()); - - // position should not have moved - assert_eq!(t.stream_position().unwrap(), 26); // tell() - - assert_eq!(t.read_to_end(&mut buf).unwrap(), 0); - assert_eq!(buf.as_slice(), b""); - assert_eq!(t.stream_position().unwrap(), 26); // tell() - buf.clear(); - - // read whole thing - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 10); - assert_eq!(buf.as_slice(), b"abcdefghij"); - buf.clear(); - - // set_len to expand beyond the end - assert!(t.set_len(40).is_ok()); - assert_eq!(t.stream_position().unwrap(), 10); // tell() - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 40); - assert_eq!( - buf.as_slice(), - &b"abcdefghij\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"[..] - ); -} - -#[test] -fn test_set_len_buffer() { - let mut t = spooled_tempfile(100); - test_set_len(&mut t); -} - -#[test] -fn test_set_len_file() { - let mut t = spooled_tempfile(100); - test_set_len(&mut t); -} - -#[test] -fn test_set_len_rollover() { - let mut buf: Vec<u8> = Vec::new(); - - let mut t = spooled_tempfile(10); - assert_eq!(t.write(b"abcde").unwrap(), 5); - assert!(!t.is_rolled()); - assert_eq!(t.stream_position().unwrap(), 5); // tell() - - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 5); - assert_eq!(buf.as_slice(), b"abcde"); - assert_eq!(t.stream_position().unwrap(), 5); // tell() - buf.clear(); - - assert!(t.set_len(20).is_ok()); - assert!(t.is_rolled()); - assert_eq!(t.stream_position().unwrap(), 5); // tell() - assert_eq!(t.seek(SeekFrom::Start(0)).unwrap(), 0); - assert_eq!(t.read_to_end(&mut buf).unwrap(), 20); - assert_eq!(buf.as_slice(), b"abcde\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); -} diff --git a/vendor/tempfile/tests/tempdir.rs b/vendor/tempfile/tests/tempdir.rs deleted file mode 100644 index 8ca7984..0000000 --- a/vendor/tempfile/tests/tempdir.rs +++ /dev/null @@ -1,176 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![deny(rust_2018_idioms)] - -use std::env; -use std::fs; -use std::path::Path; -use std::sync::mpsc::channel; -use std::thread; - -use tempfile::{Builder, TempDir}; - -fn test_tempdir() { - let path = { - let p = Builder::new().prefix("foobar").tempdir_in(".").unwrap(); - let p = p.path(); - assert!(p.to_str().unwrap().contains("foobar")); - p.to_path_buf() - }; - assert!(!path.exists()); -} - -fn test_prefix() { - let tmpfile = TempDir::with_prefix_in("prefix", ".").unwrap(); - let name = tmpfile.path().file_name().unwrap().to_str().unwrap(); - assert!(name.starts_with("prefix")); -} - -fn test_customnamed() { - let tmpfile = Builder::new() - .prefix("prefix") - .suffix("suffix") - .rand_bytes(12) - .tempdir() - .unwrap(); - let name = tmpfile.path().file_name().unwrap().to_str().unwrap(); - assert!(name.starts_with("prefix")); - assert!(name.ends_with("suffix")); - assert_eq!(name.len(), 24); -} - -fn test_rm_tempdir() { - let (tx, rx) = channel(); - let f = move || { - let tmp = TempDir::new().unwrap(); - tx.send(tmp.path().to_path_buf()).unwrap(); - panic!("panic to unwind past `tmp`"); - }; - let _ = thread::spawn(f).join(); - let path = rx.recv().unwrap(); - assert!(!path.exists()); - - let tmp = TempDir::new().unwrap(); - let path = tmp.path().to_path_buf(); - let f = move || { - let _tmp = tmp; - panic!("panic to unwind past `tmp`"); - }; - let _ = thread::spawn(f).join(); - assert!(!path.exists()); - - let path; - { - let f = move || TempDir::new().unwrap(); - - let tmp = thread::spawn(f).join().unwrap(); - path = tmp.path().to_path_buf(); - assert!(path.exists()); - } - assert!(!path.exists()); - - let path; - { - let tmp = TempDir::new().unwrap(); - path = tmp.into_path(); - } - assert!(path.exists()); - fs::remove_dir_all(&path).unwrap(); - assert!(!path.exists()); -} - -fn test_rm_tempdir_close() { - let (tx, rx) = channel(); - let f = move || { - let tmp = TempDir::new().unwrap(); - tx.send(tmp.path().to_path_buf()).unwrap(); - tmp.close().unwrap(); - panic!("panic when unwinding past `tmp`"); - }; - let _ = thread::spawn(f).join(); - let path = rx.recv().unwrap(); - assert!(!path.exists()); - - let tmp = TempDir::new().unwrap(); - let path = tmp.path().to_path_buf(); - let f = move || { - let tmp = tmp; - tmp.close().unwrap(); - panic!("panic when unwinding past `tmp`"); - }; - let _ = thread::spawn(f).join(); - assert!(!path.exists()); - - let path; - { - let f = move || TempDir::new().unwrap(); - - let tmp = thread::spawn(f).join().unwrap(); - path = tmp.path().to_path_buf(); - assert!(path.exists()); - tmp.close().unwrap(); - } - assert!(!path.exists()); - - let path; - { - let tmp = TempDir::new().unwrap(); - path = tmp.into_path(); - } - assert!(path.exists()); - fs::remove_dir_all(&path).unwrap(); - assert!(!path.exists()); -} - -fn dont_double_panic() { - let r: Result<(), _> = thread::spawn(move || { - let tmpdir = TempDir::new().unwrap(); - // Remove the temporary directory so that TempDir sees - // an error on drop - fs::remove_dir(tmpdir.path()).unwrap(); - // Panic. If TempDir panics *again* due to the rmdir - // error then the process will abort. - panic!(); - }) - .join(); - assert!(r.is_err()); -} - -fn in_tmpdir<F>(f: F) -where - F: FnOnce(), -{ - let tmpdir = TempDir::new().unwrap(); - assert!(env::set_current_dir(tmpdir.path()).is_ok()); - - f(); -} - -fn pass_as_asref_path() { - let tempdir = TempDir::new().unwrap(); - takes_asref_path(&tempdir); - - fn takes_asref_path<T: AsRef<Path>>(path: T) { - let path = path.as_ref(); - assert!(path.exists()); - } -} - -#[test] -fn main() { - in_tmpdir(test_tempdir); - in_tmpdir(test_prefix); - in_tmpdir(test_customnamed); - in_tmpdir(test_rm_tempdir); - in_tmpdir(test_rm_tempdir_close); - in_tmpdir(dont_double_panic); - in_tmpdir(pass_as_asref_path); -} diff --git a/vendor/tempfile/tests/tempfile.rs b/vendor/tempfile/tests/tempfile.rs deleted file mode 100644 index c2f6844..0000000 --- a/vendor/tempfile/tests/tempfile.rs +++ /dev/null @@ -1,68 +0,0 @@ -#![deny(rust_2018_idioms)] - -use std::fs; -use std::io::{Read, Seek, SeekFrom, Write}; -#[cfg(target_os = "linux")] -use std::{ - sync::mpsc::{sync_channel, TryRecvError}, - thread, -}; - -#[test] -fn test_basic() { - let mut tmpfile = tempfile::tempfile().unwrap(); - write!(tmpfile, "abcde").unwrap(); - tmpfile.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - tmpfile.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); -} - -#[test] -fn test_cleanup() { - let tmpdir = tempfile::tempdir().unwrap(); - { - let mut tmpfile = tempfile::tempfile_in(&tmpdir).unwrap(); - write!(tmpfile, "abcde").unwrap(); - } - let num_files = fs::read_dir(&tmpdir).unwrap().count(); - assert!(num_files == 0); -} - -// Only run this test on Linux. MacOS doesn't like us creating so many files, apparently. -#[cfg(target_os = "linux")] -#[test] -fn test_pathological_cleaner() { - let tmpdir = tempfile::tempdir().unwrap(); - let (tx, rx) = sync_channel(0); - let cleaner_thread = thread::spawn(move || { - let tmp_path = rx.recv().unwrap(); - while rx.try_recv() == Err(TryRecvError::Empty) { - let files = fs::read_dir(&tmp_path).unwrap(); - for f in files { - // skip errors - if f.is_err() { - continue; - } - let f = f.unwrap(); - let _ = fs::remove_file(f.path()); - } - } - }); - - // block until cleaner_thread makes progress - tx.send(tmpdir.path().to_owned()).unwrap(); - // need 40-400 iterations to encounter race with cleaner on original system - for _ in 0..10000 { - let mut tmpfile = tempfile::tempfile_in(&tmpdir).unwrap(); - write!(tmpfile, "abcde").unwrap(); - tmpfile.seek(SeekFrom::Start(0)).unwrap(); - let mut buf = String::new(); - tmpfile.read_to_string(&mut buf).unwrap(); - assert_eq!("abcde", buf); - } - - // close the channel to make cleaner_thread exit - drop(tx); - cleaner_thread.join().expect("The cleaner thread failed"); -} |