From ab587c98e49d1ac51029b8ef66bc5509eac6ba8e Mon Sep 17 00:00:00 2001
From: Romain Ardiet <romain.ardiet@gmail.com>
Date: Thu, 29 Nov 2018 11:33:18 +0100
Subject: [PATCH 1/2] Apply and configure rustfmt in the project

---
 .travis.yml | 11 +++++++++-
 src/lib.rs  | 62 ++++++++++++++++++++++++++++-------------------------
 src/main.rs |  2 +-
 3 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 613564f..c0d3676 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1 +1,10 @@
-language: rust
\ No newline at end of file
+language: rust
+
+before_script:
+  - rustup component add rustfmt-preview
+
+script:
+  - cargo fmt --all -- --check
+  - cargo build
+  - cargo test
+
diff --git a/src/lib.rs b/src/lib.rs
index 426349f..8637090 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,45 +1,49 @@
 use std::fs::File;
-use std::io::SeekFrom;
-use std::io::BufReader;
-use std::io::prelude::*;
 use std::io;
+use std::io::prelude::*;
+use std::io::BufReader;
+use std::io::ErrorKind;
+use std::io::SeekFrom;
+use std::os::unix::fs::MetadataExt;
 use std::thread::sleep;
 use std::time::Duration;
-use std::os::unix::fs::MetadataExt;
-use std::io::ErrorKind;
 
-pub struct LogWatcher{
+pub struct LogWatcher {
     filename: String,
     inode: u64,
     pos: u64,
     reader: BufReader<File>,
-    finish: bool
+    finish: bool,
 }
 
 impl LogWatcher {
     pub fn register(filename: String) -> Result<LogWatcher, io::Error> {
         let f = match File::open(filename.clone()) {
             Ok(x) => x,
-            Err(err) => return Err(err)
+            Err(err) => return Err(err),
         };
 
         let metadata = match f.metadata() {
             Ok(x) => x,
-            Err(err) => return Err(err)
+            Err(err) => return Err(err),
         };
 
         let mut reader = BufReader::new(f);
         let pos = metadata.len();
         reader.seek(SeekFrom::Start(pos)).unwrap();
-        Ok(LogWatcher{filename: filename,
-                      inode: metadata.ino(),
-                      pos: pos,
-                      reader: reader,
-                      finish: false})
+        Ok(LogWatcher {
+            filename: filename,
+            inode: metadata.ino(),
+            pos: pos,
+            reader: reader,
+            finish: false,
+        })
     }
 
     fn reopen_if_log_rotated<F: ?Sized>(&mut self, callback: &F)
-        where F: Fn(String) {
+    where
+        F: Fn(String),
+    {
         loop {
             match File::open(self.filename.clone()) {
                 Ok(x) => {
@@ -51,7 +55,7 @@ impl LogWatcher {
                             continue;
                         }
                     };
-                    if metadata.ino() != self.inode{
+                    if metadata.ino() != self.inode {
                         self.finish = true;
                         self.watch(callback);
                         self.finish = false;
@@ -59,14 +63,13 @@ impl LogWatcher {
                         self.reader = BufReader::new(f);
                         self.pos = 0;
                         self.inode = metadata.ino();
-                    }
-                    else{
+                    } else {
                         sleep(Duration::new(1, 0));
                     }
                     break;
-                },
+                }
                 Err(err) => {
-                    if err.kind() == ErrorKind::NotFound{
+                    if err.kind() == ErrorKind::NotFound {
                         sleep(Duration::new(1, 0));
                         continue;
                     }
@@ -76,27 +79,28 @@ impl LogWatcher {
     }
 
     pub fn watch<F: ?Sized>(&mut self, callback: &F)
-        where F: Fn(String) {
-        loop{
+    where
+        F: Fn(String),
+    {
+        loop {
             let mut line = String::new();
             let resp = self.reader.read_line(&mut line);
-            match resp{
+            match resp {
                 Ok(len) => {
-                    if len > 0{
+                    if len > 0 {
                         self.pos += len as u64;
                         self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
                         callback(line.replace("\n", ""));
                         line.clear();
-                    }else {
-                        if self.finish{
+                    } else {
+                        if self.finish {
                             break;
-                        }
-                        else{
+                        } else {
                             self.reopen_if_log_rotated(callback);
                             self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
                         }
                     }
-                },
+                }
                 Err(err) => {
                     println!("{}", err);
                 }
diff --git a/src/main.rs b/src/main.rs
index ca2a835..dfc085e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,7 @@ use std::process::exit;
 extern crate logwatcher;
 use logwatcher::LogWatcher;
 
-fn main(){
+fn main() {
     let filename = match args().nth(1) {
         Some(x) => x,
         None => {

From e83d3b67bbef2426a905f5f19cc1c57d0f406d38 Mon Sep 17 00:00:00 2001
From: Romain Ardiet <romain.ardiet@gmail.com>
Date: Thu, 29 Nov 2018 12:01:41 +0100
Subject: [PATCH 2/2] Highlight code blocks inside Readme

---
 README.md | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 997650a..b019c5e 100644
--- a/README.md
+++ b/README.md
@@ -14,18 +14,24 @@ Note: Tested only in Linux
 
 First, add the following to your `Cargo.toml`
 
-    [dependencies]
-    logwatcher = "0.1"
+```toml
+[dependencies]
+logwatcher = "0.1"
+```
 
 Add to your code,
 
-    extern crate logwatcher;
-    use logwatcher::LogWatcher;
+```rust
+extern crate logwatcher;
+use logwatcher::LogWatcher;
+```
 
 Register the logwatcher, pass a closure and watch it!
 
-    let mut log_watcher = LogWatcher::register("/var/log/check.log".to_string()).unwrap();
+```rust
+let mut log_watcher = LogWatcher::register("/var/log/check.log".to_string()).unwrap();
 
-    log_watcher.watch(&|line: String| {
-        println!("Line {}", line);
-    });
+log_watcher.watch(&|line: String| {
+    println!("Line {}", line);
+});
+```