code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/error-stack-0.5.0/examples/demo.rs

@@ -1,115 +0,0 @@
-// This is the same example also used in the README.md. When updating this, don't forget updating
-// the README.md as well. This is mainly used to test the code and generate the output shown.
-
-use core::fmt;
-
-use error_stack::{Context, Report, Result, ResultExt};
-
-#[derive(Debug)]
-struct ParseExperimentError;
-
-impl fmt::Display for ParseExperimentError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.write_str("invalid experiment description")
-    }
-}
-
-impl Context for ParseExperimentError {}
-
-// Reason: false-positive, try_fold is fail-fast, our implementation is fail-slow.
-#[expect(clippy::manual_try_fold)]
-fn parse_experiment(description: &str) -> Result<Vec<(u64, u64)>, ParseExperimentError> {
-    let values = description
-        .split(' ')
-        .map(|value| {
-            value
-                .parse::<u64>()
-                .attach_printable_lazy(|| format!("{value:?} could not be parsed as experiment"))
-        })
-        .map(|value| value.map(|ok| (ok, 2 * ok)))
-        .fold(Ok(vec![]), |accum, value| match (accum, value) {
-            (Ok(mut accum), Ok(value)) => {
-                accum.push(value);
-
-                Ok(accum)
-            }
-            (Ok(_), Err(err)) => Err(err),
-            (Err(accum), Ok(_)) => Err(accum),
-            (Err(mut accum), Err(err)) => {
-                accum.extend_one(err);
-
-                Err(accum)
-            }
-        })
-        .change_context(ParseExperimentError)?;
-
-    Ok(values)
-}
-
-#[derive(Debug)]
-struct ExperimentError;
-
-impl fmt::Display for ExperimentError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.write_str("experiment error: could not run experiment")
-    }
-}
-
-impl Context for ExperimentError {}
-
-#[expect(
-    clippy::manual_try_fold,
-    reason = "false-positive, try_fold is fail-fast, our implementation is fail-slow"
-)]
-fn start_experiments(
-    experiment_ids: &[usize],
-    experiment_descriptions: &[&str],
-) -> Result<Vec<u64>, ExperimentError> {
-    let experiments = experiment_ids
-        .iter()
-        .map(|exp_id| {
-            let description = experiment_descriptions.get(*exp_id).ok_or_else(|| {
-                Report::new(ExperimentError)
-                    .attach_printable(format!("experiment {exp_id} has no valid description"))
-            })?;
-
-            let experiments = parse_experiment(description)
-                .attach_printable(format!("experiment {exp_id} could not be parsed"))
-                .change_context(ExperimentError)?;
-
-            let experiments = experiments
-                .into_iter()
-                .map(|(a, b)| move || a * b)
-                .collect::<Vec<_>>();
-
-            Ok(experiments)
-        })
-        .fold(
-            Ok(vec![]),
-            |accum: Result<_, ExperimentError>, value| match (accum, value) {
-                (Ok(mut accum), Ok(value)) => {
-                    accum.extend(value);
-
-                    Ok(accum)
-                }
-                (Ok(_), Err(err)) => Err(err),
-                (Err(accum), Ok(_)) => Err(accum),
-                (Err(mut accum), Err(err)) => {
-                    accum.extend_one(err);
-
-                    Err(accum)
-                }
-            },
-        )
-        .attach_printable("unable to set up experiments")?;
-
-    Ok(experiments.iter().map(|experiment| experiment()).collect())
-}
-
-fn main() -> Result<(), ExperimentError> {
-    let experiment_ids = &[0, 2, 3];
-    let experiment_descriptions = &["10", "20", "3o 4a"];
-    start_experiments(experiment_ids, experiment_descriptions)?;
-
-    Ok(())
-}

data/ext/cargo-vendor/error-stack-0.5.0/examples/detect.rs

@@ -1,68 +0,0 @@
-#![expect(clippy::print_stdout, clippy::use_debug)]
-// This example shows how you can use the `supports-color` and `supports-unicode` crates to
-// automatically enable or disable the color mode and set the appropriate charset.
-// Your default terminal should automatically show colored unicode output, to emulate a terminal
-// that does not support color set your `$TERM` env-variable **temporarily** to "dumb", or set the
-// env-variable `NO_COLOR=1`. To emulate no-unicode support set your `$TERM` variable
-// **temporarily** to `linux`.
-
-use core::fmt::{Display, Formatter};
-use std::path::Path;
-
-use error_stack::{
-    fmt::{Charset, ColorMode},
-    Report, Result,
-};
-
-type Config = String;
-
-#[derive(Debug)]
-struct ParseConfigError;
-
-impl Display for ParseConfigError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        f.write_str("unable to parse config")
-    }
-}
-
-impl core::error::Error for ParseConfigError {}
-
-fn parse_config(path: impl AsRef<Path>) -> Result<Config, ParseConfigError> {
-    _ = path.as_ref();
-
-    /*
-       usually you would actually do something here, we just error out, for a more complete example
-       check out the other examples
-    */
-
-    Err(Report::new(ParseConfigError).attach_printable("unable to read configuration"))
-}
-
-fn main() {
-    // error-stack only uses ANSI codes for colors
-    let supports_color = supports_color::on_cached(supports_color::Stream::Stdout)
-        .map_or(false, |level| level.has_basic);
-
-    let color_mode = if supports_color {
-        ColorMode::Color
-    } else {
-        ColorMode::None
-    };
-
-    let supports_unicode = supports_unicode::on(supports_unicode::Stream::Stdout);
-
-    let charset = if supports_unicode {
-        Charset::Utf8
-    } else {
-        Charset::Ascii
-    };
-
-    Report::set_color_mode(color_mode);
-    Report::set_charset(charset);
-
-    if let Err(err) = parse_config("config.json") {
-        // if you would use `eprintln!` instead, you should check support on `Stream::Stderr`
-        // instead.
-        println!("{err:?}");
-    }
-}

data/ext/cargo-vendor/error-stack-0.5.0/examples/exit_code.rs

@@ -1,24 +0,0 @@
-//! Example of using `attach` to set a custom exit code. Requires nightly and std feature.
-
-use std::process::{ExitCode, Termination};
-
-use error_stack::{Context, Report};
-
-#[derive(Debug)]
-struct CustomError;
-
-impl Context for CustomError {}
-
-impl core::fmt::Display for CustomError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str("Custom Error")
-    }
-}
-
-fn main() -> ExitCode {
-    let report = Report::new(CustomError)
-        .attach(ExitCode::from(100))
-        .attach_printable("this error has an exit code of 100!");
-
-    report.report()
-}

data/ext/cargo-vendor/error-stack-0.5.0/examples/parse_config.rs

@@ -1,51 +0,0 @@
-#![expect(clippy::print_stderr, unreachable_pub, clippy::use_debug)]
-// This is the same example also used in `lib.rs`. When updating this, don't forget updating the doc
-// example as well. This example is mainly used to generate the output shown in the documentation.
-
-use core::fmt;
-use std::{fs, path::Path};
-
-use error_stack::{Context, Report, ResultExt};
-
-pub type Config = String;
-
-#[derive(Debug)]
-struct ParseConfigError;
-
-impl ParseConfigError {
-    #[must_use]
-    pub const fn new() -> Self {
-        Self
-    }
-}
-
-impl fmt::Display for ParseConfigError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.write_str("Could not parse configuration file")
-    }
-}
-
-impl Context for ParseConfigError {}
-
-struct Suggestion(&'static str);
-
-fn parse_config(path: impl AsRef<Path>) -> Result<Config, Report<ParseConfigError>> {
-    let path = path.as_ref();
-
-    let content = fs::read_to_string(path)
-        .change_context(ParseConfigError::new())
-        .attach(Suggestion("use a file you can read next time!"))
-        .attach_printable_lazy(|| format!("could not read file {path:?}"))?;
-
-    Ok(content)
-}
-
-fn main() {
-    if let Err(report) = parse_config("config.json") {
-        eprintln!("{report:?}");
-        #[cfg(nightly)]
-        for suggestion in report.request_ref::<Suggestion>() {
-            eprintln!("Suggestion: {}", suggestion.0);
-        }
-    }
-}

data/ext/cargo-vendor/error-stack-0.5.0/rust-toolchain.toml

@@ -1,4 +0,0 @@
-[toolchain]
-# Please also update the badges in `README.md`s (`error-stack` and `error-stack-macros`), and `src/lib.rs`
-channel = "nightly-2024-07-08"
-components = ['rustfmt', 'clippy', 'llvm-tools-preview', 'miri', 'rust-src', 'rust-analyzer']

data/ext/cargo-vendor/error-stack-0.5.0/src/compat/anyhow.rs

@@ -1,34 +0,0 @@
-use anyhow::Error as AnyhowError;
-
-use crate::{Frame, IntoReportCompat, Report, Result};
-
-impl<T> IntoReportCompat for core::result::Result<T, AnyhowError> {
-    type Err = AnyhowError;
-    type Ok = T;
-
-    #[track_caller]
-    fn into_report(self) -> Result<T, AnyhowError> {
-        match self {
-            Ok(t) => Ok(t),
-            Err(anyhow) => {
-                #[cfg(feature = "std")]
-                let sources = anyhow
-                    .chain()
-                    .skip(1)
-                    .map(ToString::to_string)
-                    .collect::<alloc::vec::Vec<_>>();
-
-                #[cfg_attr(not(feature = "std"), allow(unused_mut))]
-                let mut report =
-                    Report::from_frame(Frame::from_anyhow(anyhow, alloc::boxed::Box::new([])));
-
-                #[cfg(feature = "std")]
-                for source in sources {
-                    report = report.attach_printable(source);
-                }
-
-                Err(report)
-            }
-        }
-    }
-}

data/ext/cargo-vendor/error-stack-0.5.0/src/compat/eyre.rs

@@ -1,31 +0,0 @@
-use eyre::Report as EyreReport;
-
-use crate::{Frame, IntoReportCompat, Report, Result};
-
-impl<T> IntoReportCompat for core::result::Result<T, EyreReport> {
-    type Err = EyreReport;
-    type Ok = T;
-
-    #[track_caller]
-    fn into_report(self) -> Result<T, EyreReport> {
-        match self {
-            Ok(t) => Ok(t),
-            Err(eyre) => {
-                let sources = eyre
-                    .chain()
-                    .skip(1)
-                    .map(alloc::string::ToString::to_string)
-                    .collect::<alloc::vec::Vec<_>>();
-
-                #[cfg_attr(not(feature = "std"), allow(unused_mut))]
-                let mut report = Report::from_frame(Frame::from_eyre(eyre, Box::new([])));
-
-                for source in sources {
-                    report = report.attach_printable(source);
-                }
-
-                Err(report)
-            }
-        }
-    }
-}

data/ext/cargo-vendor/error-stack-0.5.0/src/compat/mod.rs

@@ -1,36 +0,0 @@
-//! Compatibility module to convert errors from other libraries into [`Report`].
-//!
-//! In order to convert these error types, use [`IntoReportCompat::into_report()`].
-
-use crate::Report;
-
-#[cfg(feature = "anyhow")]
-mod anyhow;
-#[cfg(feature = "eyre")]
-mod eyre;
-
-/// Compatibility trait to convert from external libraries to [`Report`].
-///
-/// **Note**: It's not possible to implement [`Context`] on other error libraries' types from within
-/// `error-stack` as the trait has a blanket implementation relying on [`Error`]. Thus, implementing
-/// the trait would violate the orphan rule; the upstream crate could implement [`Error`] and this
-/// would imply an implementation for [`Context`]. This also implies, that it's not possible to
-/// implement [`ResultExt`] from within `error-stack`.
-///
-/// [`ResultExt`]: crate::ResultExt
-/// [`Context`]: crate::Context
-/// [`Error`]: core::error::Error
-pub trait IntoReportCompat: Sized {
-    /// Type of the [`Ok`] value in the [`Result`]
-    type Ok;
-
-    /// Type of the resulting [`Err`] variant wrapped inside a [`Report<E>`].
-    ///
-    /// [`Report<E>`]: crate::Report
-    type Err;
-
-    /// Converts the [`Err`] variant of the [`Result`] to a [`Report`]
-    ///
-    /// [`Report`]: crate::Report
-    fn into_report(self) -> Result<Self::Ok, Report<Self::Err>>;
-}

data/ext/cargo-vendor/error-stack-0.5.0/src/context.rs

@@ -1,132 +0,0 @@
-#[cfg(any(feature = "std", rust_1_81))]
-use alloc::string::{String, ToString};
-#[cfg(rust_1_81)]
-use core::error::Error;
-#[cfg(nightly)]
-use core::error::Request;
-use core::fmt;
-#[cfg(all(feature = "std", not(rust_1_81)))]
-use std::error::Error;
-
-use crate::Report;
-
-/// Defines the current context of a [`Report`].
-///
-/// When in a `std` environment or on a nightly toolchain, every [`Error`] is a valid `Context`.
-/// This trait is not limited to [`Error`]s and can also be manually implemented on a type.
-///
-/// ## Example
-///
-/// Used for creating a [`Report`] or for switching the [`Report`]'s context:
-///
-/// ```rust
-/// use std::{fmt, fs, io};
-///
-/// use error_stack::{Context, Result, ResultExt, Report};
-///
-/// # type Config = ();
-/// #[derive(Debug)]
-/// pub enum ConfigError {
-///     ParseError,
-/// }
-///
-/// impl fmt::Display for ConfigError {
-///     # #[allow(unused_variables)] // `fmt` is not used in this example
-///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-///         # const _: &str = stringify! {
-///         ...
-///         # }; Ok(())
-///     }
-/// }
-///
-/// // In this scenario, `Error` is not implemented for `ConfigError` for some reason, so implement
-/// // `Context` manually.
-/// impl Context for ConfigError {}
-///
-/// pub fn read_file(path: &str) -> Result<String, io::Error> {
-///     // Creates a `Report` from `io::Error`, the current context is `io::Error`
-///     fs::read_to_string(path).map_err(Report::from)
-/// }
-///
-/// pub fn parse_config(path: &str) -> Result<Config, ConfigError> {
-///     // The return type of `parse_config` requires another context. By calling `change_context`
-///     // the context may be changed.
-///     read_file(path).change_context(ConfigError::ParseError)?;
-///
-///     # const _: &str = stringify! {
-///     ...
-///     # }; Ok(())
-/// }
-/// # let err = parse_config("invalid-path").unwrap_err();
-/// # assert!(err.contains::<io::Error>());
-/// # assert!(err.contains::<ConfigError>());
-/// ```
-pub trait Context: fmt::Display + fmt::Debug + Send + Sync + 'static {
-    /// Provide values which can then be requested by [`Report`].
-    #[cfg(nightly)]
-    #[allow(unused_variables)]
-    fn provide<'a>(&'a self, request: &mut Request<'a>) {}
-
-    /// Returns the source of the error, if any.
-    ///
-    /// This method only exists to avoid the requirement of specialization and to get the sources
-    /// for `Error`.
-    #[doc(hidden)]
-    #[cfg(any(feature = "std", rust_1_81))]
-    fn __source(&self) -> Option<&(dyn Error + 'static)> {
-        None
-    }
-}
-
-/// Captures an error message as the context of a [`Report`].
-#[cfg(any(feature = "std", rust_1_81))]
-pub(crate) struct SourceContext(String);
-
-#[cfg(any(feature = "std", rust_1_81))]
-impl SourceContext {
-    pub(crate) fn from_error(value: &dyn Error) -> Self {
-        Self(value.to_string())
-    }
-}
-
-#[cfg(any(feature = "std", rust_1_81))]
-impl fmt::Debug for SourceContext {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.0, fmt)
-    }
-}
-
-#[cfg(any(feature = "std", rust_1_81))]
-impl fmt::Display for SourceContext {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0, fmt)
-    }
-}
-
-#[cfg(any(feature = "std", rust_1_81))]
-impl Context for SourceContext {}
-
-impl<C> From<C> for Report<C>
-where
-    C: Context,
-{
-    #[track_caller]
-    #[inline]
-    fn from(context: C) -> Self {
-        Self::new(context)
-    }
-}
-
-#[cfg(any(feature = "std", rust_1_81))]
-impl<C: Error + Send + Sync + 'static> Context for C {
-    #[cfg(nightly)]
-    fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        Error::provide(self, request);
-    }
-
-    #[doc(hidden)]
-    #[inline]
-    fn __source(&self) -> Option<&(dyn Error + 'static)> {
-        self.source()
-    }
-}

data/ext/cargo-vendor/error-stack-0.5.0/src/error.rs

@@ -1,47 +0,0 @@
-#![cfg(any(feature = "std", rust_1_81))]
-
-#[cfg(rust_1_81)]
-use core::error::Error;
-#[cfg(nightly)]
-use core::error::Request;
-use core::fmt;
-#[cfg(all(feature = "std", not(rust_1_81)))]
-use std::error::Error;
-
-use crate::Report;
-
-#[repr(transparent)]
-pub(crate) struct ReportError<C>(Report<C>);
-
-impl<C> ReportError<C> {
-    pub(crate) const fn new(report: Report<C>) -> Self {
-        Self(report)
-    }
-
-    pub(crate) const fn from_ref(report: &Report<C>) -> &Self {
-        // SAFETY: `ReportError` is a `repr(transparent)` wrapper around `Report`.
-        unsafe { &*(report as *const Report<C>).cast() }
-    }
-}
-
-impl<C> fmt::Debug for ReportError<C> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.0, fmt)
-    }
-}
-
-impl<C> fmt::Display for ReportError<C> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0, fmt)
-    }
-}
-
-#[cfg(any(feature = "std", rust_1_81))]
-impl<C> Error for ReportError<C> {
-    #[cfg(nightly)]
-    fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        self.0
-            .frames()
-            .for_each(|frame| frame.as_error().provide(request));
-    }
-}

data/ext/cargo-vendor/error-stack-0.5.0/src/fmt/charset.rs

@@ -1,114 +0,0 @@
-use crate::{
-    fmt::r#override::{AtomicOverride, AtomicPreference},
-    Report,
-};
-
-/// The available supported charsets
-///
-/// Can be accessed through [`crate::fmt::HookContext::charset`], and set via
-/// [`Report::set_charset`].
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
-pub enum Charset {
-    /// Terminal of the user supports utf-8
-    ///
-    /// This is the default if no charset has been explicitly set.
-    // we assume that most fonts and terminals nowadays support Utf8, which is why this is
-    // the default
-    #[default]
-    Utf8,
-
-    /// Terminal of the user supports ASCII
-    Ascii,
-}
-
-impl Charset {
-    pub(super) fn load() -> Self {
-        CHARSET_OVERRIDE.load()
-    }
-}
-
-/// Value layout:
-/// `0x00`: `Charset::Ascii`
-/// `0x01`: `Charset::Utf8`
-///
-/// all others: default to [`Self::default`]
-impl AtomicPreference for Charset {
-    fn from_u8(value: u8) -> Self {
-        match value {
-            0x00 => Self::Ascii,
-            0x01 => Self::Utf8,
-            _ => Self::default(),
-        }
-    }
-
-    fn into_u8(self) -> u8 {
-        match self {
-            Self::Ascii => 0x00,
-            Self::Utf8 => 0x01,
-        }
-    }
-}
-
-static CHARSET_OVERRIDE: AtomicOverride<Charset> = AtomicOverride::new();
-
-impl Report<()> {
-    /// Set the charset preference
-    ///
-    /// The value defaults to [`Charset::Utf8`].
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # // we only test the snapshot on nightly, therefore report is unused (so is render)
-    /// # #![cfg_attr(not(nightly), allow(dead_code, unused_variables, unused_imports))]
-    /// use std::io::{Error, ErrorKind};
-    ///
-    /// use error_stack::{report, Report};
-    /// use error_stack::fmt::{Charset};
-    ///
-    /// struct Suggestion(&'static str);
-    ///
-    /// Report::install_debug_hook::<Suggestion>(|Suggestion(value), context| {
-    ///     match context.charset() {
-    ///         Charset::Utf8 => context.push_body(format!("📝 {value}")),
-    ///         Charset::Ascii => context.push_body(format!("suggestion: {value}"))
-    ///     };
-    /// });
-    ///
-    /// let report =
-    ///     report!(Error::from(ErrorKind::InvalidInput)).attach(Suggestion("oh no, try again"));
-    ///
-    /// # fn render(value: String) -> String {
-    /// #     let backtrace = regex::Regex::new(r"backtrace no\. (\d+)\n(?:  .*\n)*  .*").unwrap();
-    /// #     let backtrace_info = regex::Regex::new(r"backtrace( with (\d+) frames)? \((\d+)\)").unwrap();
-    /// #
-    /// #     let value = backtrace.replace_all(&value, "backtrace no. $1\n  [redacted]");
-    /// #     let value = backtrace_info.replace_all(value.as_ref(), "backtrace ($3)");
-    /// #
-    /// #     ansi_to_html::convert(value.as_ref()).unwrap()
-    /// # }
-    /// #
-    /// Report::set_charset(Charset::Utf8);
-    /// println!("{report:?}");
-    /// # #[cfg(nightly)]
-    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_utf8.snap")].assert_eq(&render(format!("{report:?}")));
-    ///
-    /// Report::set_charset(Charset::Ascii);
-    /// println!("{report:?}");
-    /// # #[cfg(nightly)]
-    /// # expect_test::expect_file![concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_ascii.snap")].assert_eq(&render(format!("{report:?}")));
-    /// ```
-    ///
-    /// Which will result in something like:
-    ///
-    /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_utf8.snap"))]
-    /// </pre>
-    ///
-    /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_ascii.snap"))]
-    /// </pre>
-    pub fn set_charset(charset: Charset) {
-        CHARSET_OVERRIDE.store(charset);
-    }
-}