cbor_cli/
import.rs

1use std::{io, process};
2
3pub fn import_from_reader<R: io::Read, W: io::Write>(
4  input_format: &str,
5  mut reader: R,
6  mut writer: &mut W,
7) -> Result<(), Box<dyn std::error::Error>> {
8  if input_format == "json" {
9    serde_json::de::Deserializer::from_reader(reader)
10      .into_iter::<serde_json::Value>()
11      .map(|v| match v {
12        Ok(v) => v,
13        Err(e) => {
14          eprintln!("Error: {:?} {} {} {:?}", e.classify(), e.column(), e.line(), e);
15          process::exit(1);
16        }
17      })
18      .for_each(|v| serde_cbor::to_writer(&mut writer, &v).unwrap());
19  } else if input_format == "yaml" {
20    let result: serde_yaml::Value = match serde_yaml::from_reader(reader) {
21      Ok(v) => v,
22      Err(e) => {
23        eprintln!("Error: {:?}, {:?}", e.location(), e);
24        process::exit(1);
25      }
26    };
27    serde_cbor::to_writer(writer, &result)?;
28  } else if input_format == "toml" {
29    let mut s = String::new();
30    reader.read_to_string(&mut s)?;
31    let result: toml::Value = match toml::de::from_str(&s) {
32      Ok(v) => v,
33      Err(e) => {
34        eprintln!("Error: {} {:?} {:?}", e.message(), e.span(), e);
35        process::exit(1);
36      }
37    };
38    serde_cbor::to_writer(writer, &result)?;
39  } else {
40    serde_cbor::de::Deserializer::from_reader(reader)
41      .into_iter::<serde_cbor::Value>()
42      .map(|v| match v {
43        Ok(v) => v,
44        Err(e) => {
45          eprintln!("Error: {:?} {} {:?}", e.classify(), e.offset(), e);
46          process::exit(1);
47        }
48      })
49      .for_each(|v| serde_cbor::to_writer(&mut writer, &v).unwrap());
50  }
51  Ok(())
52}
53
54#[cfg(test)]
55mod tests {
56  use super::*;
57  use common_testing::assert;
58
59  #[test]
60  fn test_import_from_reader_from_json() {
61    // Imports some JSON data.
62    let input = b"[1,2]";
63    let mut output = Vec::new();
64    import_from_reader("json", &input[..], &mut output).unwrap();
65    // println!("{:x?}", output);
66    assert::equal_hex_bytes(&output, "820102");
67  }
68
69  #[test]
70  fn test_import_from_reader_from_yaml() {
71    // Imports some YAML data.
72    let input = b"- 1\n- 2\n";
73    let mut output = Vec::new();
74    import_from_reader("yaml", &input[..], &mut output).unwrap();
75    // println!("{:x?}", output);
76    assert::equal_hex_bytes(&output, "820102");
77  }
78
79  #[test]
80  fn test_import_from_reader_from_toml() {
81    // Imports some TOML data.
82    let input = b"foo = 1\nbar = 2\n";
83    let mut output = Vec::new();
84    import_from_reader("toml", &input[..], &mut output).unwrap();
85    // println!("{:x?}", output);
86    assert::equal_hex_bytes(&output, "a263666f6f016362617202");
87  }
88
89  #[test]
90  fn test_import_from_reader_from_cbor() {
91    // Imports some CBOR data.
92    let input = b"\x82\x01\x02";
93    let mut output = Vec::new();
94    import_from_reader("cbor", &input[..], &mut output).unwrap();
95    // println!("{:x?}", output);
96    assert::equal_hex_bytes(&output, "820102");
97  }
98}