Support SMILE

Cargo.toml

@@ -44,6 +44,7 @@ rmpv = "0.4.2"
 serde = "1.0.102"
 serde-hjson = "0.9.1"
 serde-protobuf = "0.8.1"
+serde-smile = "0.1.3"
 serde_cbor = "0.10.2"
 serde_json = "1.0.41"
 serde_yaml = "0.8.11"

src/bin/rq.rs

@@ -65,6 +65,9 @@ pub struct Options {
     /// Input is a series of YAML documents.
     #[structopt(short = "y", long = "input-yaml")]
     pub flag_input_yaml: bool,
+    /// Input is formatted as SMILE
+    #[structopt(short = "s", long = "input-smile")]
+    pub flag_input_smile: bool,
 
     #[structopt(short = "A", long = "output-avro")]
     pub flag_output_avro: Option<String>,
@@ -84,6 +87,8 @@ pub struct Options {
     pub flag_output_toml: bool,
     #[structopt(short = "Y", long = "output-yaml")]
     pub flag_output_yaml: bool,
+    #[structopt(short = "S", long = "output-smile")]
+    pub flag_output_smile: bool,
 
     #[structopt(short = "l", long = "log")]
     pub flag_log: Option<String>,
@@ -179,6 +184,9 @@ fn run(args: &Options) -> rq::error::Result<()> {
     } else if args.flag_input_yaml {
         let source = rq::value::yaml::source(&mut input);
         run_source(args, source)
+    } else if args.flag_input_smile {
+        let source = rq::value::smile::source(&mut input)?;
+        run_source(args, source)
     } else if args.flag_input_raw {
         let source = rq::value::raw::source(&mut input);
         run_source(args, source)
@@ -277,6 +285,9 @@ where
             rq::value::yaml::sink,
             rq::value::yaml::sink
         )
+    } else if args.flag_output_smile {
+        let sink = rq::value::smile::sink(&mut output)?;
+        run_source_sink(source, sink)
     } else if args.flag_output_raw {
         let sink = rq::value::raw::sink(&mut output);
         run_source_sink(source, sink)
@@ -593,6 +604,30 @@ mod test {
         assert!(a.flag_output_cbor);
     }
 
+    #[test]
+    fn test_docopt_input_smile() {
+        let a = parse_args(&["rq", "-s"]);
+        assert!(a.flag_input_smile);
+    }
+
+    #[test]
+    fn test_docopt_input_smile_long() {
+        let a = parse_args(&["rq", "--input-smile"]);
+        assert!(a.flag_input_smile);
+    }
+
+    #[test]
+    fn test_docopt_output_smile() {
+        let a = parse_args(&["rq", "-S"]);
+        assert!(a.flag_output_smile);
+    }
+
+    #[test]
+    fn test_docopt_output_smile_long() {
+        let a = parse_args(&["rq", "--output-smile"]);
+        assert!(a.flag_output_smile);
+    }
+
     #[test]
     fn test_docopt_input_protobuf() {
         let a = parse_args(&["rq", "-p", ".foo.Bar"]);

src/error.rs

@@ -46,6 +46,8 @@ pub enum Error {
     TomlDeserialize(#[cause] toml::de::Error),
     #[fail(display = "TOML serialize error")]
     TomlSerialize(#[cause] toml::ser::Error),
+    #[fail(display = "SMILE error")]
+    Smile(#[cause] serde_smile::Error),
     #[fail(display = "glob error")]
     Glob(#[cause] glob::GlobError),
     #[fail(display = "glob pattern error")]
@@ -142,6 +144,7 @@ gen_from!(serde_yaml::Error, Yaml);
 gen_from!(yaml_rust::ScanError, YamlScan);
 gen_from!(toml::de::Error, TomlDeserialize);
 gen_from!(toml::ser::Error, TomlSerialize);
+gen_from!(serde_smile::Error, Smile);
 gen_from!(glob::GlobError, Glob);
 gen_from!(glob::PatternError, GlobPattern);
 gen_from!(csv::Error, Csv);

src/value/mod.rs

@@ -14,6 +14,7 @@ pub mod json;
 pub mod messagepack;
 pub mod protobuf;
 pub mod raw;
+pub mod smile;
 pub mod toml;
 pub mod yaml;
 

src/value/smile.rs

@@ -0,0 +1,82 @@
+use crate::error;
+
+use crate::value;
+use serde;
+use serde_smile;
+use std::fmt;
+use std::io;
+
+pub struct Source<R>(
+    serde_smile::de::StreamDeserializer<
+        'static,
+        serde_smile::de::IoRead<io::BufReader<R>>,
+        value::Value,
+    >,
+)
+where
+    R: io::Read;
+
+pub struct Sink<W>(serde_smile::ser::Serializer<W>)
+where
+    W: io::Write;
+
+#[inline]
+pub fn source<R>(r: R) -> error::Result<Source<R>>
+where
+    R: io::Read,
+{
+    Ok(Source(
+        serde_smile::de::Deserializer::new(serde_smile::de::IoRead::new(io::BufReader::new(r)))?
+            .into_iter(),
+    ))
+}
+
+#[inline]
+pub fn sink<W>(w: W) -> error::Result<Sink<W>>
+where
+    W: io::Write,
+{
+    Ok(Sink(
+        serde_smile::ser::Serializer::builder()
+            .shared_strings(true)
+            .build(w)?,
+    ))
+}
+
+impl<R> value::Source for Source<R>
+where
+    R: io::Read,
+{
+    #[inline]
+    fn read(&mut self) -> error::Result<Option<value::Value>> {
+        Ok(self.0.next().transpose()?)
+    }
+}
+
+impl<W> value::Sink for Sink<W>
+where
+    W: io::Write,
+{
+    #[inline]
+    fn write(&mut self, v: value::Value) -> error::Result<()> {
+        Ok(serde::Serialize::serialize(&v, &mut self.0)?)
+    }
+}
+
+impl<R> fmt::Debug for Source<R>
+where
+    R: io::Read,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("SmileSource").finish()
+    }
+}
+
+impl<W> fmt::Debug for Sink<W>
+where
+    W: io::Write,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("SmileSink").finish()
+    }
+}