gesha-core 0.0.12

Core functionality for Gesha project
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crate::conversions::Error::FormatFailed;
use crate::{conversions, io};
use console::{Style, StyledObject};
use gesha_collections::partial_result::PartialResult;
use std::path::PathBuf;

pub type Result<A> = std::result::Result<A, Error>;

pub type Output<A> = PartialResult<A, Error>;

#[derive(Debug)]
pub enum Error {
    OpenApiTypes {
        path: PathBuf,
        cause: openapi_types::Error,
    },

    Conversion {
        path: PathBuf,
        cause: conversions::Error,
    },

    Io(io::Error),

    Multiple(Vec<Self>),

    #[cfg(feature = "testing")]
    Testing(crate::testing::Error),
}

impl Error {
    pub fn detail(&self, theme: ErrorTheme) -> String {
        match self {
            Error::Conversion {
                cause: FormatFailed { detail },
                ..
            } => {
                format!("rustfmt>\n{}", detail)
            }
            Error::Conversion {
                path,
                cause: conversions::Error::TransformBroken { detail },
            } => {
                format!(
                    "internal error: transform broken.\n{}\n{}",
                    path.display(),
                    detail,
                )
            }
            Error::Multiple(errors) => errors
                .iter()
                .map(|e| e.detail(theme))
                .collect::<Vec<_>>()
                .join("\n"),

            #[cfg(feature = "testing")]
            Error::Testing(crate::testing::Error::DiffDetected {
                output,
                actual,
                expected,
            }) => {
                let style = theme.diff_style();
                format!(
                    "\n {: <10} : {}\n {} : {}\n\n{}",
                    style.src_lines,
                    actual.to_string_lossy(),
                    style.dst_lines,
                    expected.to_string_lossy(),
                    output
                )
            }
            _ => {
                format!("{:#?}", self)
            }
        }
    }
    pub fn conversion<A: Into<PathBuf>>(path: A) -> impl Fn(conversions::Error) -> Self {
        let path = path.into();
        move |cause| Self::Conversion {
            path: path.clone(),
            cause,
        }
    }
    pub fn openapi<A: Into<PathBuf>>(path: A) -> impl Fn(openapi_types::Error) -> Self {
        let path = path.into();
        move |cause| Self::OpenApiTypes {
            path: path.clone(),
            cause,
        }
    }
    pub fn dump(&self) -> String {
        self.detail(ErrorTheme::Test)
    }
}

#[derive(Copy, Clone)]
pub enum ErrorTheme {
    Test,
    Overwrite,
}

pub struct DiffStyle {
    src_lines: StyledObject<&'static str>,
    dst_lines: StyledObject<&'static str>,
}

impl ErrorTheme {
    pub fn diff_style(&self) -> DiffStyle {
        match self {
            ErrorTheme::Test => DiffStyle {
                src_lines: Style::new().red().apply_to("- actual"),
                dst_lines: Style::new().green().apply_to("+ expected"),
            },
            ErrorTheme::Overwrite => DiffStyle {
                src_lines: Style::new().red().apply_to("- current"),
                dst_lines: Style::new().green().apply_to("+ modified"),
            },
        }
    }
}