Run `cargo fmt`

Signed-off-by: Matthias Beyer <matthias.beyer@atos.net>

5 files changed, 119 insertions, 49 deletions

diff --git a/src/log/item.rs b/src/log/item.rs
index 0bcf40d..9518479 100644
--- a/src/log/item.rs
+++ b/src/log/item.rs
@@ -29,11 +29,11 @@ pub enum LogItem {
 impl LogItem {
     pub fn display(&self) -> Result<Display> {
         match self {
-            LogItem::Line(s)         => Ok(Display(String::from_utf8(s.to_vec())?)),
-            LogItem::Progress(u)     => Ok(Display(format!("#BUTIDO:PROGRESS:{}", u))),
+            LogItem::Line(s) => Ok(Display(String::from_utf8(s.to_vec())?)),
+            LogItem::Progress(u) => Ok(Display(format!("#BUTIDO:PROGRESS:{}", u))),
             LogItem::CurrentPhase(p) => Ok(Display(format!("#BUTIDO:PHASE:{}", p))),
-            LogItem::State(Ok(()))   => Ok(Display("#BUTIDO:STATE:OK".to_string())),
-            LogItem::State(Err(s))   => Ok(Display(format!("#BUTIDO:STATE:ERR:{}", s))),
+            LogItem::State(Ok(())) => Ok(Display("#BUTIDO:STATE:OK".to_string())),
+            LogItem::State(Err(s)) => Ok(Display(format!("#BUTIDO:STATE:ERR:{}", s))),
         }
     }
 }
@@ -41,4 +41,3 @@ impl LogItem {
 #[derive(parse_display::Display)]
 #[display("{0}")]
 pub struct Display(String);
-
diff --git a/src/log/mod.rs b/src/log/mod.rs
index 7f6923d..155413f 100644
--- a/src/log/mod.rs
+++ b/src/log/mod.rs
@@ -18,4 +18,3 @@ mod sink;
 pub use sink::*;
 
 mod util;
-
diff --git a/src/log/parser.rs b/src/log/parser.rs
index 109db0a..91835cd 100644
--- a/src/log/parser.rs
+++ b/src/log/parser.rs
@@ -20,15 +20,17 @@ use futures::TryStreamExt;
 use pom::parser::Parser as PomParser;
 use shiplift::tty::TtyChunk;
 
-use crate::log::LogItem;
 use crate::log::util::*;
+use crate::log::LogItem;
 
 type IoResult<T> = RResult<T, futures::io::Error>;
 
 pub fn buffer_stream_to_line_stream<S>(stream: S) -> impl Stream<Item = IoResult<String>>
-    where S: Stream<Item = shiplift::Result<TtyChunk>> + std::marker::Unpin
+where
+    S: Stream<Item = shiplift::Result<TtyChunk>> + std::marker::Unpin,
 {
-    stream.map(|r| r.map(TtyChunkBuf::from))
+    stream
+        .map(|r| r.map(TtyChunkBuf::from))
         .map_err(|e| futures::io::Error::new(futures::io::ErrorKind::Other, e))
         .into_async_read()
         .lines()
@@ -46,7 +48,8 @@ impl ParsedLog {
     }
 
     pub fn is_successfull(&self) -> Option<bool> {
-        self.0.iter()
+        self.0
+            .iter()
             .rev()
             .filter_map(|line| match line {
                 LogItem::State(Ok(_)) => Some(true),
@@ -75,29 +78,26 @@ pub fn parser<'a>() -> PomParser<'a, u8, LogItem> {
     }
 
     fn string<'a>() -> PomParser<'a, u8, String> {
-        let special_char = sym(b'\\') | sym(b'/') | sym(b'"')
-                | sym(b'b').map(|_|b'\x08') | sym(b'f').map(|_|b'\x0C')
-                | sym(b'n').map(|_|b'\n') | sym(b'r').map(|_|b'\r') | sym(b't').map(|_|b'\t');
+        let special_char = sym(b'\\')
+            | sym(b'/')
+            | sym(b'"')
+            | sym(b'b').map(|_| b'\x08')
+            | sym(b'f').map(|_| b'\x0C')
+            | sym(b'n').map(|_| b'\n')
+            | sym(b'r').map(|_| b'\r')
+            | sym(b't').map(|_| b'\t');
         let escape_sequence = sym(b'\\') * special_char;
         let string = (none_of(b"\\\"") | escape_sequence).repeat(0..);
 
         string.convert(String::from_utf8)
     }
 
-    (
-        seq(b"#BUTIDO:") * (
-            (seq(b"PROGRESS:") * number.map(LogItem::Progress))
-            |
-            (seq(b"PHASE:") * string().map(LogItem::CurrentPhase))
-            |
-            (
-                (seq(b"STATE:ERR:") * string().map(|s| LogItem::State(Err(s))))
-                |
-                seq(b"STATE:OK").map(|_| LogItem::State(Ok(())))
-            )
-        )
-    )
-    | ignored().map(LogItem::Line)
+    (seq(b"#BUTIDO:")
+        * ((seq(b"PROGRESS:") * number.map(LogItem::Progress))
+            | (seq(b"PHASE:") * string().map(LogItem::CurrentPhase))
+            | ((seq(b"STATE:ERR:") * string().map(|s| LogItem::State(Err(s))))
+                | seq(b"STATE:OK").map(|_| LogItem::State(Ok(()))))))
+        | ignored().map(LogItem::Line)
 }
 
 #[cfg(test)]
@@ -112,12 +112,11 @@ mod tests {
             LogItem::Line(buf) => {
                 let line = String::from_utf8(buf.to_vec()).unwrap();
                 format!("LogItem::Line({})", line)
-            },
+            }
             other => format!("{:?}", other),
         }
     }
 
-
     #[test]
     fn test_non_log() {
         let s = "foo bar";
@@ -170,7 +169,12 @@ mod tests {
 
         assert!(r.is_ok(), "Not ok: {:?}", r);
         let r = r.unwrap();
-        assert_eq!(r, LogItem::CurrentPhase(String::from("a")), "Expected CurrentPhase(a), got: {}", prettify_item(&r));
+        assert_eq!(
+            r,
+            LogItem::CurrentPhase(String::from("a")),
+            "Expected CurrentPhase(a), got: {}",
+            prettify_item(&r)
+        );
     }
 
     #[test]
@@ -183,7 +187,12 @@ mod tests {
 
         assert!(r.is_ok(), "Not ok: {:?}", r);
         let r = r.unwrap();
-        assert_eq!(r, LogItem::CurrentPhase(String::from("a\n\n            ")), "Expected CurrentPhase(a), got: {}", prettify_item(&r));
+        assert_eq!(
+            r,
+            LogItem::CurrentPhase(String::from("a\n\n            ")),
+            "Expected CurrentPhase(a), got: {}",
+            prettify_item(&r)
+        );
     }
 
     #[test]
@@ -210,61 +219,126 @@ mod tests {
             .collect::<Result<Vec<_>>>();
 
         assert!(res.is_ok());
-        let res   = res.unwrap();
+        let res = res.unwrap();
         let mut i = res.iter();
 
         {
             let elem = i.next().unwrap();
             let expe = LogItem::Progress(0);
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             let elem = i.next().unwrap();
             let expe = LogItem::Line("Some log line".bytes().collect());
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             let elem = i.next().unwrap();
             let expe = LogItem::CurrentPhase(String::from("configure"));
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             let expe = LogItem::Line("Some log line".bytes().collect());
 
             let elem = i.next().unwrap();
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
 
             let elem = i.next().unwrap();
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
 
             let elem = i.next().unwrap();
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             let elem = i.next().unwrap();
             let expe = LogItem::CurrentPhase(String::from("Build"));
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             let expe = LogItem::Line("Some other log line".bytes().collect());
 
             let elem = i.next().unwrap();
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
 
             let elem = i.next().unwrap();
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
 
             let elem = i.next().unwrap();
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             let elem = i.next().unwrap();
             let expe = LogItem::State(Ok(()));
-            assert_eq!(*elem, expe, "Expected {}: {:?}", prettify_item(&expe), prettify_item(elem));
+            assert_eq!(
+                *elem,
+                expe,
+                "Expected {}: {:?}",
+                prettify_item(&expe),
+                prettify_item(elem)
+            );
         }
         {
             assert!(i.next().is_none());
         }
     }
 }
-
diff --git a/src/log/sink.rs b/src/log/sink.rs
index 7308f8d..7eeaabf 100644
--- a/src/log/sink.rs
+++ b/src/log/sink.rs
@@ -19,4 +19,3 @@ pub trait LogSink: Sized {
         Ok(())
     }
 }
-
diff --git a/src/log/util.rs b/src/log/util.rs
index 783ee47..fac6d65 100644
--- a/src/log/util.rs
+++ b/src/log/util.rs
@@ -11,7 +11,7 @@
 use shiplift::tty::TtyChunk;
 
 pub enum TtyChunkBuf {
-    StdIn (Vec<u8>),
+    StdIn(Vec<u8>),
     StdOut(Vec<u8>),
     StdErr(Vec<u8>),
 }
@@ -19,7 +19,7 @@ pub enum TtyChunkBuf {
 impl From<TtyChunk> for TtyChunkBuf {
     fn from(c: TtyChunk) -> Self {
         match c {
-            TtyChunk::StdIn(buffer)  => TtyChunkBuf::StdIn (buffer),
+            TtyChunk::StdIn(buffer) => TtyChunkBuf::StdIn(buffer),
             TtyChunk::StdOut(buffer) => TtyChunkBuf::StdOut(buffer),
             TtyChunk::StdErr(buffer) => TtyChunkBuf::StdErr(buffer),
         }
@@ -29,10 +29,9 @@ impl From<TtyChunk> for TtyChunkBuf {
 impl AsRef<[u8]> for TtyChunkBuf {
     fn as_ref(&self) -> &[u8] {
         match self {
-            TtyChunkBuf::StdIn(buffer)  => buffer.as_ref(),
+            TtyChunkBuf::StdIn(buffer) => buffer.as_ref(),
             TtyChunkBuf::StdOut(buffer) => buffer.as_ref(),
             TtyChunkBuf::StdErr(buffer) => buffer.as_ref(),
         }
     }
 }
-