Merge pull request #6 from romibuzi/formatting

Formatting with rustfmt

.travis.yml

@@ -1 +1,10 @@
 language: rust
+
+before_script:
+  - rustup component add rustfmt-preview
+
+script:
+  - cargo fmt --all -- --check
+  - cargo build
+  - cargo test
+

README.md

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

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 {
     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,
+        Ok(LogWatcher {
+            filename: filename,
             inode: metadata.ino(),
             pos: pos,
             reader: reader,
-                      finish: false})
+            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) => {
@@ -59,12 +63,11 @@ 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 {
                         sleep(Duration::new(1, 0));
@@ -76,7 +79,9 @@ impl LogWatcher {
     }
 
     pub fn watch<F: ?Sized>(&mut self, callback: &F)
-        where F: Fn(String) {
+    where
+        F: Fn(String),
+    {
         loop {
             let mut line = String::new();
             let resp = self.reader.read_line(&mut line);
@@ -90,13 +95,12 @@ impl LogWatcher {
                     } 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);
                 }