Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 388 insertions, 0 deletions

diff --git a/vendor/is-terminal/src/lib.rs b/vendor/is-terminal/src/lib.rs
new file mode 100644
index 0000000..56810b7
--- /dev/null
+++ b/vendor/is-terminal/src/lib.rs
@@ -0,0 +1,388 @@
+//! is-terminal is a simple utility that answers one question:
+//!
+//! > Is this a terminal?
+//!
+//! A "terminal", also known as a "tty", is an I/O device which may be
+//! interactive and may support color and other special features. This crate
+//! doesn't provide any of those features; it just answers this one question.
+//!
+//! On Unix-family platforms, this is effectively the same as the [`isatty`]
+//! function for testing whether a given stream is a terminal, though it
+//! accepts high-level stream types instead of raw file descriptors.
+//!
+//! On Windows, it uses a variety of techniques to determine whether the
+//! given stream is a terminal.
+//!
+//! # Example
+//!
+//! ```rust
+//! use is_terminal::IsTerminal;
+//!
+//! if std::io::stdout().is_terminal() {
+//!     println!("stdout is a terminal")
+//! }
+//! ```
+//!
+//! [`isatty`]: https://man7.org/linux/man-pages/man3/isatty.3.html
+
+#![cfg_attr(unix, no_std)]
+
+#[cfg(not(any(windows, target_os = "hermit", target_os = "unknown")))]
+use rustix::fd::AsFd;
+#[cfg(target_os = "hermit")]
+use std::os::hermit::io::AsFd;
+#[cfg(windows)]
+use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle};
+#[cfg(windows)]
+use windows_sys::Win32::Foundation::HANDLE;
+
+/// Extension trait to check whether something is a terminal.
+pub trait IsTerminal {
+    /// Returns true if this is a terminal.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use is_terminal::IsTerminal;
+    ///
+    /// if std::io::stdout().is_terminal() {
+    ///     println!("stdout is a terminal")
+    /// }
+    /// ```
+    fn is_terminal(&self) -> bool;
+}
+
+/// Returns `true` if `this` is a terminal.
+///
+/// This is equivalent to calling `this.is_terminal()` and exists only as a
+/// convenience to calling the trait method [`IsTerminal::is_terminal`]
+/// without importing the trait.
+///
+/// # Example
+///
+/// ```
+/// if is_terminal::is_terminal(&std::io::stdout()) {
+///     println!("stdout is a terminal")
+/// }
+/// ```
+pub fn is_terminal<T: IsTerminal>(this: T) -> bool {
+    this.is_terminal()
+}
+
+#[cfg(not(any(windows, target_os = "unknown")))]
+impl<Stream: AsFd> IsTerminal for Stream {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        #[cfg(any(unix, target_os = "wasi"))]
+        {
+            rustix::termios::isatty(self)
+        }
+
+        #[cfg(target_os = "hermit")]
+        {
+            use std::os::hermit::io::AsRawFd;
+            hermit_abi::isatty(self.as_fd().as_fd().as_raw_fd())
+        }
+    }
+}
+
+#[cfg(windows)]
+impl<Stream: AsHandle> IsTerminal for Stream {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        handle_is_console(self.as_handle())
+    }
+}
+
+// The Windows implementation here is copied from `handle_is_console` in
+// std/src/sys/windows/io.rs in Rust at revision
+// d7b0bcb20f2f7d5f3ea3489d56ece630147e98f5.
+
+#[cfg(windows)]
+fn handle_is_console(handle: BorrowedHandle<'_>) -> bool {
+    use windows_sys::Win32::System::Console::{
+        GetConsoleMode, GetStdHandle, STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
+    };
+
+    let handle = handle.as_raw_handle();
+
+    unsafe {
+        // A null handle means the process has no console.
+        if handle.is_null() {
+            return false;
+        }
+
+        let mut out = 0;
+        if GetConsoleMode(handle as HANDLE, &mut out) != 0 {
+            // False positives aren't possible. If we got a console then we definitely have a console.
+            return true;
+        }
+
+        // At this point, we *could* have a false negative. We can determine that this is a true
+        // negative if we can detect the presence of a console on any of the standard I/O streams. If
+        // another stream has a console, then we know we're in a Windows console and can therefore
+        // trust the negative.
+        for std_handle in [STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE] {
+            let std_handle = GetStdHandle(std_handle);
+            if std_handle != 0
+                && std_handle != handle as HANDLE
+                && GetConsoleMode(std_handle, &mut out) != 0
+            {
+                return false;
+            }
+        }
+
+        // Otherwise, we fall back to an msys hack to see if we can detect the presence of a pty.
+        msys_tty_on(handle as HANDLE)
+    }
+}
+
+/// Returns true if there is an MSYS tty on the given handle.
+///
+/// This incoproates d7b0bcb20f2f7d5f3ea3489d56ece630147e98f5
+#[cfg(windows)]
+unsafe fn msys_tty_on(handle: HANDLE) -> bool {
+    use std::ffi::c_void;
+    use windows_sys::Win32::{
+        Foundation::MAX_PATH,
+        Storage::FileSystem::{
+            FileNameInfo, GetFileInformationByHandleEx, GetFileType, FILE_TYPE_PIPE,
+        },
+    };
+
+    // Early return if the handle is not a pipe.
+    if GetFileType(handle) != FILE_TYPE_PIPE {
+        return false;
+    }
+
+    /// Mirrors windows_sys::Win32::Storage::FileSystem::FILE_NAME_INFO, giving
+    /// it a fixed length that we can stack allocate
+    #[repr(C)]
+    #[allow(non_snake_case)]
+    struct FILE_NAME_INFO {
+        FileNameLength: u32,
+        FileName: [u16; MAX_PATH as usize],
+    }
+    let mut name_info = FILE_NAME_INFO {
+        FileNameLength: 0,
+        FileName: [0; MAX_PATH as usize],
+    };
+    // Safety: buffer length is fixed.
+    let res = GetFileInformationByHandleEx(
+        handle,
+        FileNameInfo,
+        &mut name_info as *mut _ as *mut c_void,
+        std::mem::size_of::<FILE_NAME_INFO>() as u32,
+    );
+    if res == 0 {
+        return false;
+    }
+
+    // Use `get` because `FileNameLength` can be out of range.
+    let s = match name_info
+        .FileName
+        .get(..name_info.FileNameLength as usize / 2)
+    {
+        None => return false,
+        Some(s) => s,
+    };
+    let name = String::from_utf16_lossy(s);
+    // Get the file name only.
+    let name = name.rsplit('\\').next().unwrap_or(&name);
+    // This checks whether 'pty' exists in the file name, which indicates that
+    // a pseudo-terminal is attached. To mitigate against false positives
+    // (e.g., an actual file name that contains 'pty'), we also require that
+    // the file name begins with either the strings 'msys-' or 'cygwin-'.)
+    let is_msys = name.starts_with("msys-") || name.starts_with("cygwin-");
+    let is_pty = name.contains("-pty");
+    is_msys && is_pty
+}
+
+#[cfg(target_os = "unknown")]
+impl IsTerminal for std::io::Stdin {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl IsTerminal for std::io::Stdout {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl IsTerminal for std::io::Stderr {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl<'a> IsTerminal for std::io::StdinLock<'a> {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl<'a> IsTerminal for std::io::StdoutLock<'a> {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl<'a> IsTerminal for std::io::StderrLock<'a> {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl<'a> IsTerminal for std::fs::File {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl IsTerminal for std::process::ChildStdin {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl IsTerminal for std::process::ChildStdout {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(target_os = "unknown")]
+impl IsTerminal for std::process::ChildStderr {
+    #[inline]
+    fn is_terminal(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "unknown"))]
+    use super::IsTerminal;
+
+    #[test]
+    #[cfg(windows)]
+    fn stdin() {
+        assert_eq!(
+            atty::is(atty::Stream::Stdin),
+            std::io::stdin().is_terminal()
+        )
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn stdout() {
+        assert_eq!(
+            atty::is(atty::Stream::Stdout),
+            std::io::stdout().is_terminal()
+        )
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn stderr() {
+        assert_eq!(
+            atty::is(atty::Stream::Stderr),
+            std::io::stderr().is_terminal()
+        )
+    }
+
+    #[test]
+    #[cfg(any(unix, target_os = "wasi"))]
+    fn stdin() {
+        assert_eq!(
+            atty::is(atty::Stream::Stdin),
+            rustix::stdio::stdin().is_terminal()
+        )
+    }
+
+    #[test]
+    #[cfg(any(unix, target_os = "wasi"))]
+    fn stdout() {
+        assert_eq!(
+            atty::is(atty::Stream::Stdout),
+            rustix::stdio::stdout().is_terminal()
+        )
+    }
+
+    #[test]
+    #[cfg(any(unix, target_os = "wasi"))]
+    fn stderr() {
+        assert_eq!(
+            atty::is(atty::Stream::Stderr),
+            rustix::stdio::stderr().is_terminal()
+        )
+    }
+
+    #[test]
+    #[cfg(any(unix, target_os = "wasi"))]
+    fn stdin_vs_libc() {
+        unsafe {
+            assert_eq!(
+                libc::isatty(libc::STDIN_FILENO) != 0,
+                rustix::stdio::stdin().is_terminal()
+            )
+        }
+    }
+
+    #[test]
+    #[cfg(any(unix, target_os = "wasi"))]
+    fn stdout_vs_libc() {
+        unsafe {
+            assert_eq!(
+                libc::isatty(libc::STDOUT_FILENO) != 0,
+                rustix::stdio::stdout().is_terminal()
+            )
+        }
+    }
+
+    #[test]
+    #[cfg(any(unix, target_os = "wasi"))]
+    fn stderr_vs_libc() {
+        unsafe {
+            assert_eq!(
+                libc::isatty(libc::STDERR_FILENO) != 0,
+                rustix::stdio::stderr().is_terminal()
+            )
+        }
+    }
+
+    // Verify that the msys_tty_on function works with long path.
+    #[test]
+    #[cfg(windows)]
+    fn msys_tty_on_path_length() {
+        use std::{fs::File, os::windows::io::AsRawHandle};
+        use windows_sys::Win32::Foundation::MAX_PATH;
+
+        let dir = tempfile::tempdir().expect("Unable to create temporary directory");
+        let file_path = dir.path().join("ten_chars_".repeat(25));
+        // Ensure that the path is longer than MAX_PATH.
+        assert!(file_path.to_string_lossy().len() > MAX_PATH as usize);
+        let file = File::create(file_path).expect("Unable to create file");
+
+        assert!(!unsafe { crate::msys_tty_on(file.as_raw_handle() as isize) });
+    }
+}