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`
 
-    [dependencies]
+```toml
-    logwatcher = "0.1"
+[dependencies]
+logwatcher = "0.1"
+```
 
 Add to your code,
 
-    extern crate logwatcher;
+```rust
-    use logwatcher::LogWatcher;
+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| {
+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{
+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) => {
@@ -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) {
+    where
-        loop{
+        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 {
+                    } else {
-                        if self.finish{
+                        if self.finish {
                             break;
-                        }
+                        } else {
-                        else{
                             self.reopen_if_log_rotated(callback);
                             self.reader.seek(SeekFrom::Start(self.pos)).unwrap();
                         }
                     }
-                },
+                }
                 Err(err) => {
                     println!("{}", err);
                 }

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 => {