zsh-module 0.3.0

A High-level framework for creating zsh modules
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

//! Zsh native log functions. This module contains high level interfaces to the zsh log functions.

use std::{
    borrow::Cow,
    ffi::{c_char, CStr, CString},
};

use zsh_sys as zsys;

use crate::ToCString;

/// Prints out a warning message from the command `cmd`. See [`crate::warn_named!`]
pub fn warn_named(cmd: impl ToCString, msg: impl ToCString) {
    let cmd_c = cmd.into_cstr();
    let msg_c = msg.into_cstr();
    unsafe { zsys::zwarnnam(cmd_c.as_ptr(), msg_c.as_ptr()) }
}

/// Prints out a warning message. See [`crate::warn!`]
pub fn warn(msg: impl ToCString) {
    let msg_c = msg.into_cstr();
    unsafe { zsys::zwarn(msg_c.as_ptr()) }
}

/// Prints out an error message. See [`crate::error!`]
pub fn error(msg: impl ToCString) {
    let msg_c = msg.into_cstr();
    unsafe { zsys::zerr(msg_c.as_ptr()) }
}

/// Prints out an error message from the command `cmd`. See [`crate::error_named!`]
pub fn error_named(cmd: impl ToCString, msg: impl ToCString) {
    let cmd = cmd.into_cstr();
    let msg = msg.into_cstr();
    unsafe { zsys::zerrnam(cmd.as_ptr(), msg.as_ptr()) }
}

#[macro_export]
/// Prints out a warning message with a command name, like [`println!`]
/// # Example
/// ```no_run
/// fn my_cd(action: &mut (), name: &str, args: &[&str]) -> zsh_module::MaybeError {
///     if args.len() > 1 {
///         zsh_module::warn_named!(name, "too much arguments!");
///     }
///     todo!()
/// }
///
/// ```
macro_rules! warn_named {
    ($cmd:expr, $msg:expr $(,$val:expr)*) => {
       $crate::log::warn_named($cmd, format!($msg, $($val),*))
    };
}

#[macro_export]
/// Prints out an error message with a command name, like [`println!`]
/// # Example
/// ```no_run
/// fn my_cd(action: &mut (), name: &str, args: &[&str]) -> zsh_module::MaybeError {
///     if args.len() > 1 {
///         zsh_module::error_named!(name, "too much arguments!");
///         return Err(todo!())
///     }
///    // code
///    todo!()
/// }
///
/// ```
macro_rules! error_named {
    ($cmd:expr, $msg:expr $(,$val:expr)*) => {
       $crate::log::error_named($cmd, format!($msg, $($val),*))
    };
}

/// Prints out a warning message, like [`println!`]
/// # Example
/// ```no_run
/// let number = 10;
/// if number != 42 {
///     zsh_module::warn!("Wrong number, expected 42, got {}", number);
/// }
///
/// ```
#[macro_export]
macro_rules! warn {
    ($msg:expr $(,$val:expr)*) => {
       $crate::log::warn(format!($msg, $($val),*))
    };
}

/// Prints out an error message, like [`println!`]
/// # Example
/// ```no_run
/// let number = 10;
/// if number != 42 {
///     zsh_module::error!("Wrong number, expected 42, got {}", number);
///     return /* error */
/// }
///
/// ```
#[macro_export]
macro_rules! error {
    ($msg:expr $(,$val:expr)*) => {
       $crate::log::error(format!($msg, $($val),*))
    };
}