tsu/lib.rs
1use std::sync::MutexGuard;
2use std::sync::Mutex;
3use toml::Value;
4use serde::ser::Serialize;
5
6/// ## toml_from_str used to parse string to toml data
7/// ```ignore
8///{
9/// let cargo_toml = tsu::toml_from_str(r#"
10/// [package]
11/// name = "useful_macro"
12/// version = "0.2.6"
13///
14/// [dependencies]
15/// serde = "1.0"
16///
17/// [dev-dependencies]
18/// serde_derive = "1.0"
19/// serde_json = "1.0"
20/// "#);
21///
22/// let package = cargo_toml.get("package").unwrap();
23/// let name = package.get("name").unwrap();
24/// println!("{:#?}", &package);
25/// println!("{:#?}", &name);
26///
27/// let dependencies = cargo_toml.get("dependencies").unwrap();
28/// println!("{:#?}", &dependencies);
29///
30/// let dev_dependencies = cargo_toml.get("dev-dependencies").unwrap();
31/// println!("{:#?}", &dev_dependencies);
32///}
33/// ```
34#[allow(warnings)]
35#[inline]
36pub fn toml_from_str(toml_str:impl ToString)-> MutexGuard<'static, Value> {
37 let toml_str_m = Box::leak(Box::new(Mutex::new(toml_str.to_string().parse::<Value>().unwrap())));
38 toml_str_m.lock().unwrap()
39}
40
41/// ## to_toml_str used to convert struct to toml string
42/// ```ignore
43///{
44/// use serde_derive::Serialize;
45/// #[derive(Serialize)]
46/// struct Human {
47/// name: String,
48/// age: u8,
49/// country: Country,
50/// }
51/// #[derive(Serialize)]
52/// struct Country {
53/// name: String,
54/// }
55/// let user = Human {
56/// name: "mike".to_string(),
57/// age: 18,
58/// country: Country {
59/// name: "country_name".to_string(),
60/// },
61/// };
62/// let toml = tsu::to_toml_str(&user);
63/// println!("{}",toml.as_str());
64///}
65/// ```
66#[inline]
67pub fn to_toml_str(toml_str:impl Serialize) -> MutexGuard<'static, String> {
68 let toml_str_m = Box::leak(Box::new(Mutex::new(toml::to_string(&toml_str).unwrap())));
69 toml_str_m.lock().unwrap()
70}
71/// ## toml_from_path used to read toml file and parse contents to toml data
72/// ```ignore
73/// {
74/// let cargo_toml = tsu::toml_from_path("./Cargo.toml");
75/// let dependencies = cargo_toml.get("dependencies").unwrap();
76/// println!("{:#?}", &dependencies);
77/// }
78/// ```
79#[inline]
80pub fn toml_from_path(toml_path:impl ToString)-> MutexGuard<'static, Value>{
81 let toml_content = String::from_utf8_lossy(&std::fs::read(&toml_path.to_string()).unwrap()).to_string();
82 toml_from_str(toml_content)
83}
84
85/// ## convert_toml_to_json used to convert toml to json
86/// ```rust
87/// use tsu::*;
88/// {
89/// let toml_data = r#"
90/// [package]
91/// name = "package_name"
92/// version = "0.3.0"
93///
94/// [dependencies]
95/// serde = "1.0"
96///
97/// [dev-dependencies]
98/// serde_derive = "1.0"
99/// serde_json = "1.0"
100/// "#;
101/// let json = convert_toml_to_json(toml_data).unwrap();
102/// assert_eq!("{\n \"dependencies\": {\n \"serde\": \"1.0\"\n },\n \"dev-dependencies\": {\n \"serde_derive\": \"1.0\",\n \"serde_json\": \"1.0\"\n },\n \"package\": {\n \"name\": \"package_name\",\n \"version\": \"0.3.0\"\n }\n}",json);
103///
104/// }
105/// ```
106#[inline]
107pub fn convert_toml_to_json(input:&str) -> Result<String, Box<dyn std::error::Error + 'static>>{
108 let val: toml::Value = toml::from_str(input).unwrap();
109 let serde_json = serde_json::to_string_pretty(&val).unwrap();
110 Ok(serde_json)
111}
112/// ## convert_json_to_toml used to convert json to toml
113/// ```rust
114/// use tsu::*;
115/// {
116/// let json_data= r#"
117/// {
118/// "data":{
119/// "version":"0.12.0",
120/// "category":"rust"
121/// }
122/// }
123/// "#;
124/// let toml = convert_json_to_toml(&json_data).unwrap();
125/// assert_eq!("[data]\nversion = '0.12.0'\ncategory = 'rust'\n",toml);
126/// }
127/// ```
128#[inline]
129pub fn convert_json_to_toml(input:&str) -> Result<String, Box<dyn std::error::Error + 'static>>{
130 use serde_json::Deserializer;
131 use toml::ser::Serializer;
132 let mut toml = String::new();
133
134 let mut deserializer = Deserializer::from_str(input);
135 let mut serializer = Serializer::pretty(&mut toml);
136 serde_transcode::transcode(&mut deserializer, &mut serializer).unwrap();
137 Ok(toml)
138}
139/// ## convert_toml_to_yaml used to convert toml to yaml
140/// ```rust
141/// use tsu::*;
142///let toml_data = r#"
143///[package]
144///name = "package_name"
145///version = "0.3.0"
146///
147///[dependencies]
148///serde = "1.0"
149///
150///[dev-dependencies]
151///serde_derive = "1.0"
152///serde_json = "1.0"
153///"#;
154///let yaml = convert_toml_to_yaml(toml_data).unwrap();
155///assert_eq!("dependencies:\n serde: '1.0'\ndev-dependencies:\n serde_derive: '1.0'\n serde_json: '1.0'\npackage:\n name: package_name\n version: 0.3.0\n",yaml);
156///```
157#[inline]
158pub fn convert_toml_to_yaml(input:&str) -> Result<String, Box<dyn std::error::Error + 'static>>{
159 let val: toml::Value = toml::from_str(input).unwrap();
160 let serde_yaml = serde_yaml::to_string(&val).unwrap();
161 Ok(serde_yaml)
162}
163
164/// ## convert_yaml_to_toml used to convert yaml to toml
165/// ```rust
166///use tsu::*;
167///let yaml_data = r"dependencies:
168/// serde: '1.0'
169///dev-dependencies:
170/// serde_derive: '1.0'
171/// serde_json: '1.0'
172///package:
173/// name: package_name
174/// version: 0.3.0";
175///assert_eq!("[dependencies]\nserde = '1.0'\n\n[dev-dependencies]\nserde_derive = '1.0'\nserde_json = '1.0'\n\n[package]\nname = 'package_name'\nversion = '0.3.0'\n",convert_yaml_to_toml(yaml_data).unwrap());
176///```
177///
178
179#[inline]
180pub fn convert_yaml_to_toml(input:&str) -> Result<String, Box<dyn std::error::Error + 'static>>{
181 use serde_yaml::Deserializer;
182 use toml::ser::Serializer;
183 let mut toml = String::new();
184
185 let deserializer = Deserializer::from_str(input);
186 let mut serializer = Serializer::pretty(&mut toml);
187 serde_transcode::transcode(deserializer, &mut serializer).unwrap();
188 Ok(toml)
189}