clap-serde 0.4.0

Provides a wrapper to deserialize clap app using serde.
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
139
140
141
142
143

#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc  = include_str!("../README.md")]

use clap::{Arg, ArgGroup, Command};
use serde::Deserializer;
use std::ops::Deref;

#[cfg(not(any(
    feature = "kebab-case-key",
    feature = "snake-case-key",
    feature = "pascal-case-key"
)))]
compile_error!("Case setting feature is missing. Either one should be set.");

#[cfg(any(
    all(feature = "kebab-case-key", feature = "snake-case-key"),
    all(feature = "kebab-case-key", feature = "pascal-case-key"),
    all(feature = "pascal-case-key", feature = "snake-case-key"),
))]
compile_error!("Case setting feature is conflicting. Only one should be set.");

#[macro_use]
mod de;
#[cfg(feature = "docsrs")]
pub mod documents;
#[cfg(feature = "yaml")]
#[deprecated(since = "0.4", note = "use serde-yaml instead")]
mod yaml;

#[cfg(all(test, feature = "snake-case-key"))]
mod tests;

#[cfg(feature = "yaml")]
pub use yaml::{yaml_to_app, YamlWrap};

/**
Deserialize [`Command`] from [`Deserializer`].
```
const CLAP_TOML: &'static str = r#"
name = "app_clap_serde"
version = "1.0"
author = "tester"
about = "test-clap-serde"
"#;
let app = clap_serde::load(&mut toml::Deserializer::new(CLAP_TOML))
    .expect("parse failed");
assert_eq!(app.get_name(), "app_clap_serde");
assert_eq!(app.get_about(), Some("test-clap-serde"));
```
*/
pub fn load<'de, D>(de: D) -> Result<Command<'de>, D::Error>
where
    D: Deserializer<'de>,
{
    use serde::Deserialize;
    CommandWrap::deserialize(de).map(|a| a.into())
}

/**
Wrapper of [`Command`] to deserialize.
```
const CLAP_TOML: &'static str = r#"
name = "app_clap_serde"
version = "1.0"
author = "tester"
about = "test-clap-serde"
"#;
let app: clap::Command = toml::from_str::<clap_serde::CommandWrap>(CLAP_TOML)
    .expect("parse failed")
    .into();
assert_eq!(app.get_name(), "app_clap_serde");
assert_eq!(app.get_about(), Some("test-clap-serde"));
```
*/
#[derive(Debug, Clone)]
pub struct CommandWrap<'a> {
    app: Command<'a>,
}

#[deprecated]
pub type AppWrap<'a> = CommandWrap<'a>;

impl<'a> From<CommandWrap<'a>> for Command<'a> {
    fn from(a: CommandWrap<'a>) -> Self {
        a.app
    }
}

impl<'a> From<Command<'a>> for CommandWrap<'a> {
    fn from(app: Command<'a>) -> Self {
        CommandWrap { app }
    }
}

impl<'a> Deref for CommandWrap<'a> {
    type Target = Command<'a>;

    fn deref(&self) -> &Self::Target {
        &self.app
    }
}

/// Wrapper of [`Arg`] to deserialize with [`DeserializeSeed`](`serde::de::DeserializeSeed`).
#[derive(Debug, Clone)]
pub struct ArgWrap<'a> {
    arg: Arg<'a>,
}

impl<'a> From<ArgWrap<'a>> for Arg<'a> {
    fn from(arg: ArgWrap<'a>) -> Self {
        arg.arg
    }
}

impl<'a> From<Arg<'a>> for ArgWrap<'a> {
    fn from(arg: Arg<'a>) -> Self {
        ArgWrap { arg }
    }
}

impl<'a> Deref for ArgWrap<'a> {
    type Target = Arg<'a>;

    fn deref(&self) -> &Self::Target {
        &self.arg
    }
}

pub(crate) struct ArgGroupWrap<'a> {
    group: ArgGroup<'a>,
}

impl<'a> From<ArgGroupWrap<'a>> for ArgGroup<'a> {
    fn from(group: ArgGroupWrap<'a>) -> Self {
        group.group
    }
}

impl<'a> From<ArgGroup<'a>> for ArgGroupWrap<'a> {
    fn from(group: ArgGroup<'a>) -> Self {
        ArgGroupWrap { group }
    }
}