micromux 0.0.7

Micromux is a local process supervisor with a terminal UI
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Diagnostics helpers.
//!
//! This module provides a small wrapper around `codespan-reporting` for emitting diagnostics
//! anchored in input sources.

use codespan_reporting::{
    diagnostic::{Diagnostic, Severity},
    files, term,
};
use parking_lot::RwLock;
use std::path::{Path, PathBuf};
use std::sync::Arc;

/// A diagnostics printer backed by [`codespan_reporting`].
#[derive(Debug, Clone)]
pub struct Printer {
    writer: Arc<term::termcolor::StandardStream>,
    diagnostic_config: term::Config,
    files: Arc<RwLock<files::SimpleFiles<String, String>>>,
}

/// Helper trait for turning various path-like values into a display name.
pub trait ToSourceName {
    /// Convert this value into a source name.
    fn to_source_name(self) -> String;
}

impl ToSourceName for String {
    fn to_source_name(self) -> String {
        self
    }
}

impl ToSourceName for &Path {
    fn to_source_name(self) -> String {
        self.to_string_lossy().to_string()
    }
}

impl ToSourceName for &PathBuf {
    fn to_source_name(self) -> String {
        self.as_path().to_source_name()
    }
}

impl Default for Printer {
    fn default() -> Self {
        Self::new(term::termcolor::ColorChoice::Auto)
    }
}

impl Printer {
    /// Create a new diagnostics printer.
    ///
    /// The `color_choice` controls whether ANSI color codes are emitted.
    #[must_use]
    pub fn new(color_choice: term::termcolor::ColorChoice) -> Self {
        let writer = term::termcolor::StandardStream::stderr(color_choice);
        let diagnostic_config = term::Config::default();
        Self {
            writer: Arc::new(writer),
            diagnostic_config,
            files: Arc::new(RwLock::new(files::SimpleFiles::new())),
        }
    }

    /// Add a new source file to this printer and return its file id.
    pub fn add_source_file(&self, name: impl ToSourceName, source: String) -> usize {
        let mut files = self.files.write();
        files.add(name.to_source_name(), source)
    }

    /// Emit a diagnostic.
    ///
    /// # Errors
    ///
    /// Returns an error if the underlying `termcolor` writer fails.
    pub fn emit(&self, diagnostic: &Diagnostic<usize>) -> Result<(), files::Error> {
        if diagnostic.is_error() {
            tracing::error!("{:?}", diagnostic);
        } else if diagnostic.is_warning() {
            tracing::warn!("{:?}", diagnostic);
        } else {
            tracing::warn!("{:?}", diagnostic);
        }
        term::emit_to_write_style(
            &mut self.writer.lock(),
            &self.diagnostic_config,
            &*self.files.read(),
            diagnostic,
        )
    }
}

/// A file identifier returned by [`Printer::add_source_file`].
pub type FileId = usize;
/// A half-open character span.
pub type Span = std::ops::Range<usize>;

/// Convert an error type into codespan diagnostics.
pub trait ToDiagnostics {
    /// Convert this error value into diagnostics.
    fn to_diagnostics<F: Copy + PartialEq>(&self, file_id: F) -> Vec<Diagnostic<F>>;
}

/// Additional helper methods for codespan diagnostics.
pub trait DiagnosticExt {
    /// Returns `true` if this diagnostic is an error.
    fn is_error(&self) -> bool;
    /// Returns `true` if this diagnostic is a warning.
    fn is_warning(&self) -> bool;
    /// Create an error diagnostic if `strict` is enabled, otherwise create a warning diagnostic.
    fn warning_or_error(strict: bool) -> Self;
}

impl<F> DiagnosticExt for Diagnostic<F> {
    fn is_error(&self) -> bool {
        match self.severity {
            Severity::Bug | Severity::Error => true,
            Severity::Warning | Severity::Note | Severity::Help => false,
        }
    }

    fn is_warning(&self) -> bool {
        match self.severity {
            Severity::Warning => true,
            Severity::Bug | Severity::Error | Severity::Note | Severity::Help => false,
        }
    }

    fn warning_or_error(strict: bool) -> Self {
        if strict {
            Self::error()
        } else {
            Self::warning()
        }
    }
}